granicus.if.org Git - icinga2/blob - lib/livestatus/hoststable.cpp

   1 /******************************************************************************
   2  * Icinga 2                                                                   *
   3  * Copyright (C) 2012-2018 Icinga Development Team (https://www.icinga.com/)  *
   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/hoststable.hpp"
  21 #include "livestatus/hostgroupstable.hpp"
  22 #include "livestatus/endpointstable.hpp"
  23 #include "icinga/host.hpp"
  24 #include "icinga/service.hpp"
  25 #include "icinga/hostgroup.hpp"
  26 #include "icinga/checkcommand.hpp"
  27 #include "icinga/eventcommand.hpp"
  28 #include "icinga/timeperiod.hpp"
  29 #include "icinga/macroprocessor.hpp"
  30 #include "icinga/icingaapplication.hpp"
  31 #include "icinga/compatutility.hpp"
  32 #include "icinga/pluginutility.hpp"
  33 #include "base/configtype.hpp"
  34 #include "base/objectlock.hpp"
  35 #include "base/json.hpp"
  36 #include "base/convert.hpp"
  37 #include "base/utility.hpp"
  38 #include <boost/tuple/tuple.hpp>
  39 #include <boost/algorithm/string/replace.hpp>
  40
  41 using namespace icinga;
  42
  43 HostsTable::HostsTable(LivestatusGroupByType type)
  44         :Table(type)
  45 {
  46         AddColumns(this);
  47 }
  48
  49 void HostsTable::AddColumns(Table *table, const String& prefix,
  50         const Column::ObjectAccessor& objectAccessor)
  51 {
  52         table->AddColumn(prefix + "name", Column(&HostsTable::NameAccessor, objectAccessor));
  53         table->AddColumn(prefix + "host_name", Column(&HostsTable::NameAccessor, objectAccessor)); //ugly compatibility hack
  54         table->AddColumn(prefix + "display_name", Column(&HostsTable::DisplayNameAccessor, objectAccessor));
  55         table->AddColumn(prefix + "alias", Column(&HostsTable::DisplayNameAccessor, objectAccessor));
  56         table->AddColumn(prefix + "address", Column(&HostsTable::AddressAccessor, objectAccessor));
  57         table->AddColumn(prefix + "address6", Column(&HostsTable::Address6Accessor, objectAccessor));
  58         table->AddColumn(prefix + "check_command", Column(&HostsTable::CheckCommandAccessor, objectAccessor));
  59         table->AddColumn(prefix + "check_command_expanded", Column(&HostsTable::CheckCommandExpandedAccessor, objectAccessor));
  60         table->AddColumn(prefix + "event_handler", Column(&HostsTable::EventHandlerAccessor, objectAccessor));
  61         table->AddColumn(prefix + "notification_period", Column(&Table::EmptyStringAccessor, objectAccessor));
  62         table->AddColumn(prefix + "check_period", Column(&HostsTable::CheckPeriodAccessor, objectAccessor));
  63         table->AddColumn(prefix + "notes", Column(&HostsTable::NotesAccessor, objectAccessor));
  64         table->AddColumn(prefix + "notes_expanded", Column(&HostsTable::NotesExpandedAccessor, objectAccessor));
  65         table->AddColumn(prefix + "notes_url", Column(&HostsTable::NotesUrlAccessor, objectAccessor));
  66         table->AddColumn(prefix + "notes_url_expanded", Column(&HostsTable::NotesUrlExpandedAccessor, objectAccessor));
  67         table->AddColumn(prefix + "action_url", Column(&HostsTable::ActionUrlAccessor, objectAccessor));
  68         table->AddColumn(prefix + "action_url_expanded", Column(&HostsTable::ActionUrlExpandedAccessor, objectAccessor));
  69         table->AddColumn(prefix + "plugin_output", Column(&HostsTable::PluginOutputAccessor, objectAccessor));
  70         table->AddColumn(prefix + "perf_data", Column(&HostsTable::PerfDataAccessor, objectAccessor));
  71         table->AddColumn(prefix + "icon_image", Column(&HostsTable::IconImageAccessor, objectAccessor));
  72         table->AddColumn(prefix + "icon_image_expanded", Column(&HostsTable::IconImageExpandedAccessor, objectAccessor));
  73         table->AddColumn(prefix + "icon_image_alt", Column(&HostsTable::IconImageAltAccessor, objectAccessor));
  74         table->AddColumn(prefix + "statusmap_image", Column(&Table::EmptyStringAccessor, objectAccessor));
  75         table->AddColumn(prefix + "long_plugin_output", Column(&HostsTable::LongPluginOutputAccessor, objectAccessor));
  76         table->AddColumn(prefix + "initial_state", Column(&Table::EmptyStringAccessor, objectAccessor));
  77         table->AddColumn(prefix + "max_check_attempts", Column(&HostsTable::MaxCheckAttemptsAccessor, objectAccessor));
  78         table->AddColumn(prefix + "flap_detection_enabled", Column(&HostsTable::FlapDetectionEnabledAccessor, objectAccessor));
  79         table->AddColumn(prefix + "check_freshness", Column(&Table::OneAccessor, objectAccessor));
  80         table->AddColumn(prefix + "process_performance_data", Column(&HostsTable::ProcessPerformanceDataAccessor, objectAccessor));
  81         table->AddColumn(prefix + "accept_passive_checks", Column(&HostsTable::AcceptPassiveChecksAccessor, objectAccessor));
  82         table->AddColumn(prefix + "event_handler_enabled", Column(&HostsTable::EventHandlerEnabledAccessor, objectAccessor));
  83         table->AddColumn(prefix + "acknowledgement_type", Column(&HostsTable::AcknowledgementTypeAccessor, objectAccessor));
  84         table->AddColumn(prefix + "check_type", Column(&HostsTable::CheckTypeAccessor, objectAccessor));
  85         table->AddColumn(prefix + "last_state", Column(&HostsTable::LastStateAccessor, objectAccessor));
  86         table->AddColumn(prefix + "last_hard_state", Column(&HostsTable::LastHardStateAccessor, objectAccessor));
  87         table->AddColumn(prefix + "current_attempt", Column(&HostsTable::CurrentAttemptAccessor, objectAccessor));
  88         table->AddColumn(prefix + "last_notification", Column(&HostsTable::LastNotificationAccessor, objectAccessor));
  89         table->AddColumn(prefix + "next_notification", Column(&HostsTable::NextNotificationAccessor, objectAccessor));
  90         table->AddColumn(prefix + "next_check", Column(&HostsTable::NextCheckAccessor, objectAccessor));
  91         table->AddColumn(prefix + "last_hard_state_change", Column(&HostsTable::LastHardStateChangeAccessor, objectAccessor));
  92         table->AddColumn(prefix + "has_been_checked", Column(&HostsTable::HasBeenCheckedAccessor, objectAccessor));
  93         table->AddColumn(prefix + "current_notification_number", Column(&HostsTable::CurrentNotificationNumberAccessor, objectAccessor));
  94         table->AddColumn(prefix + "pending_flex_downtime", Column(&Table::ZeroAccessor, objectAccessor));
  95         table->AddColumn(prefix + "total_services", Column(&HostsTable::TotalServicesAccessor, objectAccessor));
  96         table->AddColumn(prefix + "checks_enabled", Column(&HostsTable::ChecksEnabledAccessor, objectAccessor));
  97         table->AddColumn(prefix + "notifications_enabled", Column(&HostsTable::NotificationsEnabledAccessor, objectAccessor));
  98         table->AddColumn(prefix + "acknowledged", Column(&HostsTable::AcknowledgedAccessor, objectAccessor));
  99         table->AddColumn(prefix + "state", Column(&HostsTable::StateAccessor, objectAccessor));
 100         table->AddColumn(prefix + "state_type", Column(&HostsTable::StateTypeAccessor, objectAccessor));
 101         table->AddColumn(prefix + "no_more_notifications", Column(&HostsTable::NoMoreNotificationsAccessor, objectAccessor));
 102         table->AddColumn(prefix + "check_flapping_recovery_notification", Column(&Table::ZeroAccessor, objectAccessor));
 103         table->AddColumn(prefix + "last_check", Column(&HostsTable::LastCheckAccessor, objectAccessor));
 104         table->AddColumn(prefix + "last_state_change", Column(&HostsTable::LastStateChangeAccessor, objectAccessor));
 105         table->AddColumn(prefix + "last_time_up", Column(&HostsTable::LastTimeUpAccessor, objectAccessor));
 106         table->AddColumn(prefix + "last_time_down", Column(&HostsTable::LastTimeDownAccessor, objectAccessor));
 107         table->AddColumn(prefix + "last_time_unreachable", Column(&HostsTable::LastTimeUnreachableAccessor, objectAccessor));
 108         table->AddColumn(prefix + "is_flapping", Column(&HostsTable::IsFlappingAccessor, objectAccessor));
 109         table->AddColumn(prefix + "scheduled_downtime_depth", Column(&HostsTable::ScheduledDowntimeDepthAccessor, objectAccessor));
 110         table->AddColumn(prefix + "is_executing", Column(&Table::ZeroAccessor, objectAccessor));
 111         table->AddColumn(prefix + "active_checks_enabled", Column(&HostsTable::ActiveChecksEnabledAccessor, objectAccessor));
 112         table->AddColumn(prefix + "check_options", Column(&Table::EmptyStringAccessor, objectAccessor));
 113         table->AddColumn(prefix + "obsess_over_host", Column(&Table::ZeroAccessor, objectAccessor));
 114         table->AddColumn(prefix + "modified_attributes", Column(&Table::ZeroAccessor, objectAccessor));
 115         table->AddColumn(prefix + "modified_attributes_list", Column(&Table::ZeroAccessor, objectAccessor));
 116         table->AddColumn(prefix + "check_interval", Column(&HostsTable::CheckIntervalAccessor, objectAccessor));
 117         table->AddColumn(prefix + "retry_interval", Column(&HostsTable::RetryIntervalAccessor, objectAccessor));
 118         table->AddColumn(prefix + "notification_interval", Column(&HostsTable::NotificationIntervalAccessor, objectAccessor));
 119         table->AddColumn(prefix + "first_notification_delay", Column(&Table::EmptyStringAccessor, objectAccessor));
 120         table->AddColumn(prefix + "low_flap_threshold", Column(&HostsTable::LowFlapThresholdAccessor, objectAccessor));
 121         table->AddColumn(prefix + "high_flap_threshold", Column(&HostsTable::HighFlapThresholdAccessor, objectAccessor));
 122         table->AddColumn(prefix + "x_3d", Column(&EmptyStringAccessor, objectAccessor));
 123         table->AddColumn(prefix + "y_3d", Column(&EmptyStringAccessor, objectAccessor));
 124         table->AddColumn(prefix + "z_3d", Column(&EmptyStringAccessor, objectAccessor));
 125         table->AddColumn(prefix + "x_2d", Column(&Table::EmptyStringAccessor, objectAccessor));
 126         table->AddColumn(prefix + "y_2d", Column(&Table::EmptyStringAccessor, objectAccessor));
 127         table->AddColumn(prefix + "latency", Column(&HostsTable::LatencyAccessor, objectAccessor));
 128         table->AddColumn(prefix + "execution_time", Column(&HostsTable::ExecutionTimeAccessor, objectAccessor));
 129         table->AddColumn(prefix + "percent_state_change", Column(&HostsTable::PercentStateChangeAccessor, objectAccessor));
 130         table->AddColumn(prefix + "in_notification_period", Column(&HostsTable::InNotificationPeriodAccessor, objectAccessor));
 131         table->AddColumn(prefix + "in_check_period", Column(&HostsTable::InCheckPeriodAccessor, objectAccessor));
 132         table->AddColumn(prefix + "contacts", Column(&HostsTable::ContactsAccessor, objectAccessor));
 133         table->AddColumn(prefix + "downtimes", Column(&HostsTable::DowntimesAccessor, objectAccessor));
 134         table->AddColumn(prefix + "downtimes_with_info", Column(&HostsTable::DowntimesWithInfoAccessor, objectAccessor));
 135         table->AddColumn(prefix + "comments", Column(&HostsTable::CommentsAccessor, objectAccessor));
 136         table->AddColumn(prefix + "comments_with_info", Column(&HostsTable::CommentsWithInfoAccessor, objectAccessor));
 137         table->AddColumn(prefix + "comments_with_extra_info", Column(&HostsTable::CommentsWithExtraInfoAccessor, objectAccessor));
 138         table->AddColumn(prefix + "custom_variable_names", Column(&HostsTable::CustomVariableNamesAccessor, objectAccessor));
 139         table->AddColumn(prefix + "custom_variable_values", Column(&HostsTable::CustomVariableValuesAccessor, objectAccessor));
 140         table->AddColumn(prefix + "custom_variables", Column(&HostsTable::CustomVariablesAccessor, objectAccessor));
 141         table->AddColumn(prefix + "filename", Column(&Table::EmptyStringAccessor, objectAccessor));
 142         table->AddColumn(prefix + "parents", Column(&HostsTable::ParentsAccessor, objectAccessor));
 143         table->AddColumn(prefix + "childs", Column(&HostsTable::ChildsAccessor, objectAccessor));
 144         table->AddColumn(prefix + "num_services", Column(&HostsTable::NumServicesAccessor, objectAccessor));
 145         table->AddColumn(prefix + "worst_service_state", Column(&HostsTable::WorstServiceStateAccessor, objectAccessor));
 146         table->AddColumn(prefix + "num_services_ok", Column(&HostsTable::NumServicesOkAccessor, objectAccessor));
 147         table->AddColumn(prefix + "num_services_warn", Column(&HostsTable::NumServicesWarnAccessor, objectAccessor));
 148         table->AddColumn(prefix + "num_services_crit", Column(&HostsTable::NumServicesCritAccessor, objectAccessor));
 149         table->AddColumn(prefix + "num_services_unknown", Column(&HostsTable::NumServicesUnknownAccessor, objectAccessor));
 150         table->AddColumn(prefix + "num_services_pending", Column(&HostsTable::NumServicesPendingAccessor, objectAccessor));
 151         table->AddColumn(prefix + "worst_service_hard_state", Column(&HostsTable::WorstServiceHardStateAccessor, objectAccessor));
 152         table->AddColumn(prefix + "num_services_hard_ok", Column(&HostsTable::NumServicesHardOkAccessor, objectAccessor));
 153         table->AddColumn(prefix + "num_services_hard_warn", Column(&HostsTable::NumServicesHardWarnAccessor, objectAccessor));
 154         table->AddColumn(prefix + "num_services_hard_crit", Column(&HostsTable::NumServicesHardCritAccessor, objectAccessor));
 155         table->AddColumn(prefix + "num_services_hard_unknown", Column(&HostsTable::NumServicesHardUnknownAccessor, objectAccessor));
 156         table->AddColumn(prefix + "hard_state", Column(&HostsTable::HardStateAccessor, objectAccessor));
 157         table->AddColumn(prefix + "pnpgraph_present", Column(&Table::ZeroAccessor, objectAccessor));
 158         table->AddColumn(prefix + "staleness", Column(&HostsTable::StalenessAccessor, objectAccessor));
 159         table->AddColumn(prefix + "groups", Column(&HostsTable::GroupsAccessor, objectAccessor));
 160         table->AddColumn(prefix + "contact_groups", Column(&HostsTable::ContactGroupsAccessor, objectAccessor));
 161         table->AddColumn(prefix + "services", Column(&HostsTable::ServicesAccessor, objectAccessor));
 162         table->AddColumn(prefix + "services_with_state", Column(&HostsTable::ServicesWithStateAccessor, objectAccessor));
 163         table->AddColumn(prefix + "services_with_info", Column(&HostsTable::ServicesWithInfoAccessor, objectAccessor));
 164         table->AddColumn(prefix + "check_source", Column(&HostsTable::CheckSourceAccessor, objectAccessor));
 165         table->AddColumn(prefix + "is_reachable", Column(&HostsTable::IsReachableAccessor, objectAccessor));
 166         table->AddColumn(prefix + "cv_is_json", Column(&HostsTable::CVIsJsonAccessor, objectAccessor));
 167         table->AddColumn(prefix + "original_attributes", Column(&HostsTable::OriginalAttributesAccessor, objectAccessor));
 168
 169         /* add additional group by values received through the object accessor */
 170         if (table->GetGroupByType() == LivestatusGroupByHostGroup) {
 171                 /* _1 = row, _2 = groupByType, _3 = groupByObject */
 172                 Log(LogDebug, "Livestatus")
 173                         << "Processing hosts group by hostgroup table.";
 174                 HostGroupsTable::AddColumns(table, "hostgroup_", std::bind(&HostsTable::HostGroupAccessor, _1, _2, _3));
 175         }
 176 }
 177
 178 String HostsTable::GetName() const
 179 {
 180         return "hosts";
 181 }
 182
 183 String HostsTable::GetPrefix() const
 184 {
 185         return "host";
 186 }
 187
 188 void HostsTable::FetchRows(const AddRowFunction& addRowFn)
 189 {
 190         if (GetGroupByType() == LivestatusGroupByHostGroup) {
 191                 for (const HostGroup::Ptr& hg : ConfigType::GetObjectsByType<HostGroup>()) {
 192                         for (const Host::Ptr& host : hg->GetMembers()) {
 193                                 /* the caller must know which groupby type and value are set for this row */
 194                                 if (!addRowFn(host, LivestatusGroupByHostGroup, hg))
 195                                         return;
 196                         }
 197                 }
 198         } else {
 199                 for (const Host::Ptr& host : ConfigType::GetObjectsByType<Host>()) {
 200                         if (!addRowFn(host, LivestatusGroupByNone, Empty))
 201                                 return;
 202                 }
 203         }
 204 }
 205
 206 Object::Ptr HostsTable::HostGroupAccessor(const Value& row, LivestatusGroupByType groupByType, const Object::Ptr& groupByObject)
 207 {
 208         /* return the current group by value set from within FetchRows()
 209          * this is the hostgrouo object used for the table join inside
 210          * in AddColumns()
 211          */
 212         if (groupByType == LivestatusGroupByHostGroup)
 213                 return groupByObject;
 214
 215         return nullptr;
 216 }
 217
 218 Value HostsTable::NameAccessor(const Value& row)
 219 {
 220         Host::Ptr host = static_cast<Host::Ptr>(row);
 221
 222         if (!host)
 223                 return Empty;
 224
 225         return host->GetName();
 226 }
 227
 228 Value HostsTable::DisplayNameAccessor(const Value& row)
 229 {
 230         Host::Ptr host = static_cast<Host::Ptr>(row);
 231
 232         if (!host)
 233                 return Empty;
 234
 235         return host->GetDisplayName();
 236 }
 237
 238 Value HostsTable::AddressAccessor(const Value& row)
 239 {
 240         Host::Ptr host = static_cast<Host::Ptr>(row);
 241
 242         if (!host)
 243                 return Empty;
 244
 245         return host->GetAddress();
 246 }
 247
 248 Value HostsTable::Address6Accessor(const Value& row)
 249 {
 250         Host::Ptr host = static_cast<Host::Ptr>(row);
 251
 252         if (!host)
 253                 return Empty;
 254
 255         return host->GetAddress6();
 256 }
 257
 258 Value HostsTable::CheckCommandAccessor(const Value& row)
 259 {
 260         Host::Ptr host = static_cast<Host::Ptr>(row);
 261
 262         if (!host)
 263                 return Empty;
 264
 265         CheckCommand::Ptr checkcommand = host->GetCheckCommand();
 266         if (checkcommand)
 267                 return CompatUtility::GetCommandName(checkcommand) + "!" + CompatUtility::GetCheckableCommandArgs(host);
 268
 269         return Empty;
 270 }
 271
 272 Value HostsTable::CheckCommandExpandedAccessor(const Value& row)
 273 {
 274         Host::Ptr host = static_cast<Host::Ptr>(row);
 275
 276         if (!host)
 277                 return Empty;
 278
 279         CheckCommand::Ptr checkcommand = host->GetCheckCommand();
 280         if (checkcommand)
 281                 return CompatUtility::GetCommandName(checkcommand) + "!" + CompatUtility::GetCheckableCommandArgs(host);
 282
 283         return Empty;
 284 }
 285
 286 Value HostsTable::EventHandlerAccessor(const Value& row)
 287 {
 288         Host::Ptr host = static_cast<Host::Ptr>(row);
 289
 290         if (!host)
 291                 return Empty;
 292
 293         EventCommand::Ptr eventcommand = host->GetEventCommand();
 294         if (eventcommand)
 295                 return CompatUtility::GetCommandName(eventcommand);
 296
 297         return Empty;
 298 }
 299
 300 Value HostsTable::CheckPeriodAccessor(const Value& row)
 301 {
 302         Host::Ptr host = static_cast<Host::Ptr>(row);
 303
 304         if (!host)
 305                 return Empty;
 306
 307         return CompatUtility::GetCheckableCheckPeriod(host);
 308 }
 309
 310 Value HostsTable::NotesAccessor(const Value& row)
 311 {
 312         Host::Ptr host = static_cast<Host::Ptr>(row);
 313
 314         if (!host)
 315                 return Empty;
 316
 317         return host->GetNotes();
 318 }
 319
 320 Value HostsTable::NotesExpandedAccessor(const Value& row)
 321 {
 322         Host::Ptr host = static_cast<Host::Ptr>(row);
 323
 324         if (!host)
 325                 return Empty;
 326
 327         MacroProcessor::ResolverList resolvers {
 328                 { "host", host },
 329                 { "icinga", IcingaApplication::GetInstance() }
 330         };
 331
 332         return MacroProcessor::ResolveMacros(host->GetNotes(), resolvers);
 333 }
 334
 335 Value HostsTable::NotesUrlAccessor(const Value& row)
 336 {
 337         Host::Ptr host = static_cast<Host::Ptr>(row);
 338
 339         if (!host)
 340                 return Empty;
 341
 342         return host->GetNotesUrl();
 343 }
 344
 345 Value HostsTable::NotesUrlExpandedAccessor(const Value& row)
 346 {
 347         Host::Ptr host = static_cast<Host::Ptr>(row);
 348
 349         if (!host)
 350                 return Empty;
 351
 352         MacroProcessor::ResolverList resolvers {
 353                 { "host", host },
 354                 { "icinga", IcingaApplication::GetInstance() }
 355         };
 356
 357         return MacroProcessor::ResolveMacros(host->GetNotesUrl(), resolvers);
 358 }
 359
 360 Value HostsTable::ActionUrlAccessor(const Value& row)
 361 {
 362         Host::Ptr host = static_cast<Host::Ptr>(row);
 363
 364         if (!host)
 365                 return Empty;
 366
 367         return host->GetActionUrl();
 368 }
 369
 370 Value HostsTable::ActionUrlExpandedAccessor(const Value& row)
 371 {
 372         Host::Ptr host = static_cast<Host::Ptr>(row);
 373
 374         if (!host)
 375                 return Empty;
 376
 377         MacroProcessor::ResolverList resolvers {
 378                 { "host", host },
 379                 { "icinga", IcingaApplication::GetInstance() }
 380         };
 381
 382         return MacroProcessor::ResolveMacros(host->GetActionUrl(), resolvers);
 383 }
 384
 385 Value HostsTable::PluginOutputAccessor(const Value& row)
 386 {
 387         Host::Ptr host = static_cast<Host::Ptr>(row);
 388
 389         if (!host)
 390                 return Empty;
 391
 392         String output;
 393         CheckResult::Ptr cr = host->GetLastCheckResult();
 394
 395         if (cr)
 396                 output = CompatUtility::GetCheckResultOutput(cr);
 397
 398         return output;
 399 }
 400
 401 Value HostsTable::PerfDataAccessor(const Value& row)
 402 {
 403         Host::Ptr host = static_cast<Host::Ptr>(row);
 404
 405         if (!host)
 406                 return Empty;
 407
 408         String perfdata;
 409         CheckResult::Ptr cr = host->GetLastCheckResult();
 410
 411         if (!cr)
 412                 return Empty;
 413
 414         return PluginUtility::FormatPerfdata(cr->GetPerformanceData());
 415 }
 416
 417 Value HostsTable::IconImageAccessor(const Value& row)
 418 {
 419         Host::Ptr host = static_cast<Host::Ptr>(row);
 420
 421         if (!host)
 422                 return Empty;
 423
 424         return host->GetIconImage();
 425 }
 426
 427 Value HostsTable::IconImageExpandedAccessor(const Value& row)
 428 {
 429         Host::Ptr host = static_cast<Host::Ptr>(row);
 430
 431         if (!host)
 432                 return Empty;
 433
 434         MacroProcessor::ResolverList resolvers {
 435                 { "host", host },
 436                 { "icinga", IcingaApplication::GetInstance() }
 437         };
 438
 439         return MacroProcessor::ResolveMacros(host->GetIconImage(), resolvers);
 440 }
 441
 442 Value HostsTable::IconImageAltAccessor(const Value& row)
 443 {
 444         Host::Ptr host = static_cast<Host::Ptr>(row);
 445
 446         if (!host)
 447                 return Empty;
 448
 449         return host->GetIconImageAlt();
 450 }
 451
 452 Value HostsTable::LongPluginOutputAccessor(const Value& row)
 453 {
 454         Host::Ptr host = static_cast<Host::Ptr>(row);
 455
 456         if (!host)
 457                 return Empty;
 458
 459         String long_output;
 460         CheckResult::Ptr cr = host->GetLastCheckResult();
 461
 462         if (cr)
 463                 long_output = CompatUtility::GetCheckResultLongOutput(cr);
 464
 465         return long_output;
 466 }
 467
 468 Value HostsTable::MaxCheckAttemptsAccessor(const Value& row)
 469 {
 470         Host::Ptr host = static_cast<Host::Ptr>(row);
 471
 472         if (!host)
 473                 return Empty;
 474
 475         return host->GetMaxCheckAttempts();
 476 }
 477
 478 Value HostsTable::FlapDetectionEnabledAccessor(const Value& row)
 479 {
 480         Host::Ptr host = static_cast<Host::Ptr>(row);
 481
 482         if (!host)
 483                 return Empty;
 484
 485         return Convert::ToLong(host->GetEnableFlapping());
 486 }
 487
 488 Value HostsTable::AcceptPassiveChecksAccessor(const Value& row)
 489 {
 490         Host::Ptr host = static_cast<Host::Ptr>(row);
 491
 492         if (!host)
 493                 return Empty;
 494
 495         return Convert::ToLong(host->GetEnablePassiveChecks());
 496 }
 497
 498 Value HostsTable::EventHandlerEnabledAccessor(const Value& row)
 499 {
 500         Host::Ptr host = static_cast<Host::Ptr>(row);
 501
 502         if (!host)
 503                 return Empty;
 504
 505         return Convert::ToLong(host->GetEnableEventHandler());
 506 }
 507
 508 Value HostsTable::AcknowledgementTypeAccessor(const Value& row)
 509 {
 510         Host::Ptr host = static_cast<Host::Ptr>(row);
 511
 512         if (!host)
 513                 return Empty;
 514
 515         ObjectLock olock(host);
 516         return host->GetAcknowledgement();
 517 }
 518
 519 Value HostsTable::CheckTypeAccessor(const Value& row)
 520 {
 521         Host::Ptr host = static_cast<Host::Ptr>(row);
 522
 523         if (!host)
 524                 return Empty;
 525
 526         return (host->GetEnableActiveChecks() ? 0 : 1); /* 0 .. active, 1 .. passive */
 527 }
 528
 529 Value HostsTable::LastStateAccessor(const Value& row)
 530 {
 531         Host::Ptr host = static_cast<Host::Ptr>(row);
 532
 533         if (!host)
 534                 return Empty;
 535
 536         return host->GetLastState();
 537 }
 538
 539 Value HostsTable::LastHardStateAccessor(const Value& row)
 540 {
 541         Host::Ptr host = static_cast<Host::Ptr>(row);
 542
 543         if (!host)
 544                 return Empty;
 545
 546         return host->GetLastHardState();
 547 }
 548
 549 Value HostsTable::CurrentAttemptAccessor(const Value& row)
 550 {
 551         Host::Ptr host = static_cast<Host::Ptr>(row);
 552
 553         if (!host)
 554                 return Empty;
 555
 556         return host->GetCheckAttempt();
 557 }
 558
 559 Value HostsTable::LastNotificationAccessor(const Value& row)
 560 {
 561         Host::Ptr host = static_cast<Host::Ptr>(row);
 562
 563         if (!host)
 564                 return Empty;
 565
 566         return CompatUtility::GetCheckableNotificationLastNotification(host);
 567 }
 568
 569 Value HostsTable::NextNotificationAccessor(const Value& row)
 570 {
 571         Host::Ptr host = static_cast<Host::Ptr>(row);
 572
 573         if (!host)
 574                 return Empty;
 575
 576         return CompatUtility::GetCheckableNotificationNextNotification(host);
 577 }
 578
 579 Value HostsTable::NextCheckAccessor(const Value& row)
 580 {
 581         Host::Ptr host = static_cast<Host::Ptr>(row);
 582
 583         if (!host)
 584                 return Empty;
 585
 586         return static_cast<int>(host->GetNextCheck());
 587 }
 588
 589 Value HostsTable::LastHardStateChangeAccessor(const Value& row)
 590 {
 591         Host::Ptr host = static_cast<Host::Ptr>(row);
 592
 593         if (!host)
 594                 return Empty;
 595
 596         return static_cast<int>(host->GetLastHardStateChange());
 597 }
 598
 599 Value HostsTable::HasBeenCheckedAccessor(const Value& row)
 600 {
 601         Host::Ptr host = static_cast<Host::Ptr>(row);
 602
 603         if (!host)
 604                 return Empty;
 605
 606         return Convert::ToLong(host->HasBeenChecked());
 607 }
 608
 609 Value HostsTable::CurrentNotificationNumberAccessor(const Value& row)
 610 {
 611         Host::Ptr host = static_cast<Host::Ptr>(row);
 612
 613         if (!host)
 614                 return Empty;
 615
 616         return CompatUtility::GetCheckableNotificationNotificationNumber(host);
 617 }
 618
 619 Value HostsTable::TotalServicesAccessor(const Value& row)
 620 {
 621         Host::Ptr host = static_cast<Host::Ptr>(row);
 622
 623         if (!host)
 624                 return Empty;
 625
 626         return host->GetTotalServices();
 627 }
 628
 629 Value HostsTable::ChecksEnabledAccessor(const Value& row)
 630 {
 631         Host::Ptr host = static_cast<Host::Ptr>(row);
 632
 633         if (!host)
 634                 return Empty;
 635
 636         return Convert::ToLong(host->GetEnableActiveChecks());
 637 }
 638
 639 Value HostsTable::NotificationsEnabledAccessor(const Value& row)
 640 {
 641         Host::Ptr host = static_cast<Host::Ptr>(row);
 642
 643         if (!host)
 644                 return Empty;
 645
 646         return Convert::ToLong(host->GetEnableNotifications());
 647 }
 648
 649 Value HostsTable::ProcessPerformanceDataAccessor(const Value& row)
 650 {
 651         Host::Ptr host = static_cast<Host::Ptr>(row);
 652
 653         if (!host)
 654                 return Empty;
 655
 656         return Convert::ToLong(host->GetEnablePerfdata());
 657 }
 658
 659 Value HostsTable::AcknowledgedAccessor(const Value& row)
 660 {
 661         Host::Ptr host = static_cast<Host::Ptr>(row);
 662
 663         if (!host)
 664                 return Empty;
 665
 666         ObjectLock olock(host);
 667         return host->IsAcknowledged();
 668 }
 669
 670 Value HostsTable::StateAccessor(const Value& row)
 671 {
 672         Host::Ptr host = static_cast<Host::Ptr>(row);
 673
 674         if (!host)
 675                 return Empty;
 676
 677         return host->IsReachable() ? host->GetState() : 2;
 678 }
 679
 680 Value HostsTable::StateTypeAccessor(const Value& row)
 681 {
 682         Host::Ptr host = static_cast<Host::Ptr>(row);
 683
 684         if (!host)
 685                 return Empty;
 686
 687         return host->GetStateType();
 688 }
 689
 690 Value HostsTable::NoMoreNotificationsAccessor(const Value& row)
 691 {
 692         Host::Ptr host = static_cast<Host::Ptr>(row);
 693
 694         if (!host)
 695                 return Empty;
 696
 697         return CompatUtility::GetCheckableNoMoreNotifications(host);
 698 }
 699
 700 Value HostsTable::LastCheckAccessor(const Value& row)
 701 {
 702         Host::Ptr host = static_cast<Host::Ptr>(row);
 703
 704         if (!host)
 705                 return Empty;
 706
 707         return static_cast<int>(host->GetLastCheck());
 708 }
 709
 710 Value HostsTable::LastStateChangeAccessor(const Value& row)
 711 {
 712         Host::Ptr host = static_cast<Host::Ptr>(row);
 713
 714         if (!host)
 715                 return Empty;
 716
 717         return static_cast<int>(host->GetLastStateChange());
 718 }
 719
 720 Value HostsTable::LastTimeUpAccessor(const Value& row)
 721 {
 722         Host::Ptr host = static_cast<Host::Ptr>(row);
 723
 724         if (!host)
 725                 return Empty;
 726
 727         return static_cast<int>(host->GetLastStateUp());
 728 }
 729
 730 Value HostsTable::LastTimeDownAccessor(const Value& row)
 731 {
 732         Host::Ptr host = static_cast<Host::Ptr>(row);
 733
 734         if (!host)
 735                 return Empty;
 736
 737         return static_cast<int>(host->GetLastStateDown());
 738 }
 739
 740 Value HostsTable::LastTimeUnreachableAccessor(const Value& row)
 741 {
 742         Host::Ptr host = static_cast<Host::Ptr>(row);
 743
 744         if (!host)
 745                 return Empty;
 746
 747         return static_cast<int>(host->GetLastStateUnreachable());
 748 }
 749
 750 Value HostsTable::IsFlappingAccessor(const Value& row)
 751 {
 752         Host::Ptr host = static_cast<Host::Ptr>(row);
 753
 754         if (!host)
 755                 return Empty;
 756
 757         return host->IsFlapping();
 758 }
 759
 760 Value HostsTable::ScheduledDowntimeDepthAccessor(const Value& row)
 761 {
 762         Host::Ptr host = static_cast<Host::Ptr>(row);
 763
 764         if (!host)
 765                 return Empty;
 766
 767         return host->GetDowntimeDepth();
 768 }
 769
 770 Value HostsTable::ActiveChecksEnabledAccessor(const Value& row)
 771 {
 772         Host::Ptr host = static_cast<Host::Ptr>(row);
 773
 774         if (!host)
 775                 return Empty;
 776
 777         return Convert::ToLong(host->GetEnableActiveChecks());
 778 }
 779
 780 Value HostsTable::CheckIntervalAccessor(const Value& row)
 781 {
 782         Host::Ptr host = static_cast<Host::Ptr>(row);
 783
 784         if (!host)
 785                 return Empty;
 786
 787         return CompatUtility::GetCheckableCheckInterval(host);
 788 }
 789
 790 Value HostsTable::RetryIntervalAccessor(const Value& row)
 791 {
 792         Host::Ptr host = static_cast<Host::Ptr>(row);
 793
 794         if (!host)
 795                 return Empty;
 796
 797         return CompatUtility::GetCheckableRetryInterval(host);
 798 }
 799
 800 Value HostsTable::NotificationIntervalAccessor(const Value& row)
 801 {
 802         Host::Ptr host = static_cast<Host::Ptr>(row);
 803
 804         if (!host)
 805                 return Empty;
 806
 807         return CompatUtility::GetCheckableNotificationNotificationInterval(host);
 808 }
 809
 810 Value HostsTable::LowFlapThresholdAccessor(const Value& row)
 811 {
 812         Host::Ptr host = static_cast<Host::Ptr>(row);
 813
 814         if (!host)
 815                 return Empty;
 816
 817         return host->GetFlappingThresholdLow();
 818 }
 819
 820 Value HostsTable::HighFlapThresholdAccessor(const Value& row)
 821 {
 822         Host::Ptr host = static_cast<Host::Ptr>(row);
 823
 824         if (!host)
 825                 return Empty;
 826
 827         return host->GetFlappingThresholdHigh();
 828 }
 829
 830 Value HostsTable::LatencyAccessor(const Value& row)
 831 {
 832         Host::Ptr host = static_cast<Host::Ptr>(row);
 833
 834         if (!host)
 835                 return Empty;
 836
 837         CheckResult::Ptr cr = host->GetLastCheckResult();
 838
 839         if (!cr)
 840                 return Empty;
 841
 842         return cr->CalculateLatency();
 843 }
 844
 845 Value HostsTable::ExecutionTimeAccessor(const Value& row)
 846 {
 847         Host::Ptr host = static_cast<Host::Ptr>(row);
 848
 849         if (!host)
 850                 return Empty;
 851
 852         CheckResult::Ptr cr = host->GetLastCheckResult();
 853
 854         if (!cr)
 855                 return Empty;
 856
 857         return cr->CalculateExecutionTime();
 858 }
 859
 860 Value HostsTable::PercentStateChangeAccessor(const Value& row)
 861 {
 862         Host::Ptr host = static_cast<Host::Ptr>(row);
 863
 864         if (!host)
 865                 return Empty;
 866
 867         return host->GetFlappingCurrent();
 868 }
 869
 870 Value HostsTable::InNotificationPeriodAccessor(const Value& row)
 871 {
 872         Host::Ptr host = static_cast<Host::Ptr>(row);
 873
 874         if (!host)
 875                 return Empty;
 876
 877         return CompatUtility::GetCheckableInNotificationPeriod(host);
 878 }
 879
 880 Value HostsTable::InCheckPeriodAccessor(const Value& row)
 881 {
 882         Host::Ptr host = static_cast<Host::Ptr>(row);
 883
 884         if (!host)
 885                 return Empty;
 886
 887         return CompatUtility::GetCheckableInCheckPeriod(host);
 888 }
 889
 890 Value HostsTable::ContactsAccessor(const Value& row)
 891 {
 892         Host::Ptr host = static_cast<Host::Ptr>(row);
 893
 894         if (!host)
 895                 return Empty;
 896
 897         Array::Ptr contact_names = new Array();
 898
 899         for (const User::Ptr& user : CompatUtility::GetCheckableNotificationUsers(host)) {
 900                 contact_names->Add(user->GetName());
 901         }
 902
 903         return contact_names;
 904 }
 905
 906 Value HostsTable::DowntimesAccessor(const Value& row)
 907 {
 908         Host::Ptr host = static_cast<Host::Ptr>(row);
 909
 910         if (!host)
 911                 return Empty;
 912
 913         Array::Ptr results = new Array();
 914
 915         for (const Downtime::Ptr& downtime : host->GetDowntimes()) {
 916                 if (downtime->IsExpired())
 917                         continue;
 918
 919                 results->Add(downtime->GetLegacyId());
 920         }
 921
 922         return results;
 923 }
 924
 925 Value HostsTable::DowntimesWithInfoAccessor(const Value& row)
 926 {
 927         Host::Ptr host = static_cast<Host::Ptr>(row);
 928
 929         if (!host)
 930                 return Empty;
 931
 932         Array::Ptr results = new Array();
 933
 934         for (const Downtime::Ptr& downtime : host->GetDowntimes()) {
 935                 if (downtime->IsExpired())
 936                         continue;
 937
 938                 Array::Ptr downtime_info = new Array();
 939                 downtime_info->Add(downtime->GetLegacyId());
 940                 downtime_info->Add(downtime->GetAuthor());
 941                 downtime_info->Add(downtime->GetComment());
 942                 results->Add(downtime_info);
 943         }
 944
 945         return results;
 946 }
 947
 948 Value HostsTable::CommentsAccessor(const Value& row)
 949 {
 950         Host::Ptr host = static_cast<Host::Ptr>(row);
 951
 952         if (!host)
 953                 return Empty;
 954
 955         Array::Ptr results = new Array();
 956         for (const Comment::Ptr& comment : host->GetComments()) {
 957                 if (comment->IsExpired())
 958                         continue;
 959
 960                 results->Add(comment->GetLegacyId());
 961         }
 962
 963         return results;
 964 }
 965
 966 Value HostsTable::CommentsWithInfoAccessor(const Value& row)
 967 {
 968         Host::Ptr host = static_cast<Host::Ptr>(row);
 969
 970         if (!host)
 971                 return Empty;
 972
 973         Array::Ptr results = new Array();
 974
 975         for (const Comment::Ptr& comment : host->GetComments()) {
 976                 if (comment->IsExpired())
 977                         continue;
 978
 979                 Array::Ptr comment_info = new Array();
 980                 comment_info->Add(comment->GetLegacyId());
 981                 comment_info->Add(comment->GetAuthor());
 982                 comment_info->Add(comment->GetText());
 983                 results->Add(comment_info);
 984         }
 985
 986         return results;
 987 }
 988
 989 Value HostsTable::CommentsWithExtraInfoAccessor(const Value& row)
 990 {
 991         Host::Ptr host = static_cast<Host::Ptr>(row);
 992
 993         if (!host)
 994                 return Empty;
 995
 996         Array::Ptr results = new Array();
 997
 998         for (const Comment::Ptr& comment : host->GetComments()) {
 999                 if (comment->IsExpired())
1000                         continue;
1001
1002                 Array::Ptr comment_info = new Array();
1003                 comment_info->Add(comment->GetLegacyId());
1004                 comment_info->Add(comment->GetAuthor());
1005                 comment_info->Add(comment->GetText());
1006                 comment_info->Add(comment->GetEntryType());
1007                 comment_info->Add(static_cast<int>(comment->GetEntryTime()));
1008                 results->Add(comment_info);
1009         }
1010
1011         return results;
1012 }
1013
1014 Value HostsTable::CustomVariableNamesAccessor(const Value& row)
1015 {
1016         Host::Ptr host = static_cast<Host::Ptr>(row);
1017
1018         if (!host)
1019                 return Empty;
1020
1021         Dictionary::Ptr vars;
1022
1023         {
1024                 ObjectLock olock(host);
1025                 vars = host->GetVars();
1026         }
1027
1028         Array::Ptr cv = new Array();
1029
1030         if (!vars)
1031                 return cv;
1032
1033         ObjectLock olock(vars);
1034         for (const Dictionary::Pair& kv : vars) {
1035                 cv->Add(kv.first);
1036         }
1037
1038         return cv;
1039 }
1040
1041 Value HostsTable::CustomVariableValuesAccessor(const Value& row)
1042 {
1043         Host::Ptr host = static_cast<Host::Ptr>(row);
1044
1045         if (!host)
1046                 return Empty;
1047
1048         Dictionary::Ptr vars;
1049
1050         {
1051                 ObjectLock olock(host);
1052                 vars = host->GetVars();
1053         }
1054
1055         Array::Ptr cv = new Array();
1056
1057         if (!vars)
1058                 return cv;
1059
1060         ObjectLock olock(vars);
1061         for (const Dictionary::Pair& kv : vars) {
1062                 if (kv.second.IsObjectType<Array>() || kv.second.IsObjectType<Dictionary>())
1063                         cv->Add(JsonEncode(kv.second));
1064                 else
1065                         cv->Add(kv.second);
1066         }
1067
1068         return cv;
1069 }
1070
1071 Value HostsTable::CustomVariablesAccessor(const Value& row)
1072 {
1073         Host::Ptr host = static_cast<Host::Ptr>(row);
1074
1075         if (!host)
1076                 return Empty;
1077
1078         Dictionary::Ptr vars;
1079
1080         {
1081                 ObjectLock olock(host);
1082                 vars = host->GetVars();
1083         }
1084
1085         Array::Ptr cv = new Array();
1086
1087         if (!vars)
1088                 return cv;
1089
1090         ObjectLock olock(vars);
1091         for (const Dictionary::Pair& kv : vars) {
1092                 Array::Ptr key_val = new Array();
1093                 key_val->Add(kv.first);
1094
1095                 if (kv.second.IsObjectType<Array>() || kv.second.IsObjectType<Dictionary>())
1096                         key_val->Add(JsonEncode(kv.second));
1097                 else
1098                         key_val->Add(kv.second);
1099
1100                 cv->Add(key_val);
1101         }
1102
1103         return cv;
1104 }
1105
1106 Value HostsTable::CVIsJsonAccessor(const Value& row)
1107 {
1108         Host::Ptr host = static_cast<Host::Ptr>(row);
1109
1110         if (!host)
1111                 return Empty;
1112
1113         Dictionary::Ptr vars;
1114
1115         {
1116                 ObjectLock olock(host);
1117                 vars = host->GetVars();
1118         }
1119
1120         if (!vars)
1121                 return Empty;
1122
1123         bool cv_is_json = false;
1124
1125         ObjectLock olock(vars);
1126         for (const Dictionary::Pair& kv : vars) {
1127                 if (kv.second.IsObjectType<Array>() || kv.second.IsObjectType<Dictionary>())
1128                         cv_is_json = true;
1129         }
1130
1131         return cv_is_json;
1132 }
1133
1134 Value HostsTable::ParentsAccessor(const Value& row)
1135 {
1136         Host::Ptr host = static_cast<Host::Ptr>(row);
1137
1138         if (!host)
1139                 return Empty;
1140
1141         Array::Ptr parents = new Array();
1142
1143         for (const Checkable::Ptr& parent : host->GetParents()) {
1144                 Host::Ptr parent_host = dynamic_pointer_cast<Host>(parent);
1145
1146                 if (!parent_host)
1147                         continue;
1148
1149                 parents->Add(parent_host->GetName());
1150         }
1151
1152         return parents;
1153 }
1154
1155 Value HostsTable::ChildsAccessor(const Value& row)
1156 {
1157         Host::Ptr host = static_cast<Host::Ptr>(row);
1158
1159         if (!host)
1160                 return Empty;
1161
1162         Array::Ptr childs = new Array();
1163
1164         for (const Checkable::Ptr& child : host->GetChildren()) {
1165                 Host::Ptr child_host = dynamic_pointer_cast<Host>(child);
1166
1167                 if (!child_host)
1168                         continue;
1169
1170                 childs->Add(child_host->GetName());
1171         }
1172
1173         return childs;
1174 }
1175
1176 Value HostsTable::NumServicesAccessor(const Value& row)
1177 {
1178         /* duplicate of TotalServices */
1179         Host::Ptr host = static_cast<Host::Ptr>(row);
1180
1181         if (!host)
1182                 return Empty;
1183
1184         return host->GetTotalServices();
1185 }
1186
1187 Value HostsTable::WorstServiceStateAccessor(const Value& row)
1188 {
1189         Host::Ptr host = static_cast<Host::Ptr>(row);
1190
1191         if (!host)
1192                 return Empty;
1193
1194         Value worst_service = ServiceOK;
1195
1196         for (const Service::Ptr& service : host->GetServices()) {
1197                 if (service->GetState() > worst_service)
1198                         worst_service = service->GetState();
1199         }
1200
1201         return worst_service;
1202 }
1203
1204 Value HostsTable::NumServicesOkAccessor(const Value& row)
1205 {
1206         Host::Ptr host = static_cast<Host::Ptr>(row);
1207
1208         if (!host)
1209                 return Empty;
1210
1211         int num_services = 0;
1212
1213         for (const Service::Ptr& service : host->GetServices()) {
1214                 if (service->GetState() == ServiceOK)
1215                         num_services++;
1216         }
1217
1218         return num_services;
1219 }
1220
1221 Value HostsTable::NumServicesWarnAccessor(const Value& row)
1222 {
1223         Host::Ptr host = static_cast<Host::Ptr>(row);
1224
1225         if (!host)
1226                 return Empty;
1227
1228         int num_services = 0;
1229
1230         for (const Service::Ptr& service : host->GetServices()) {
1231                 if (service->GetState() == ServiceWarning)
1232                         num_services++;
1233         }
1234
1235         return num_services;
1236 }
1237
1238 Value HostsTable::NumServicesCritAccessor(const Value& row)
1239 {
1240         Host::Ptr host = static_cast<Host::Ptr>(row);
1241
1242         if (!host)
1243                 return Empty;
1244
1245         int num_services = 0;
1246
1247         for (const Service::Ptr& service : host->GetServices()) {
1248                 if (service->GetState() == ServiceCritical)
1249                         num_services++;
1250         }
1251
1252         return num_services;
1253 }
1254
1255 Value HostsTable::NumServicesUnknownAccessor(const Value& row)
1256 {
1257         Host::Ptr host = static_cast<Host::Ptr>(row);
1258
1259         if (!host)
1260                 return Empty;
1261
1262         int num_services = 0;
1263
1264         for (const Service::Ptr& service : host->GetServices()) {
1265                 if (service->GetState() == ServiceUnknown)
1266                         num_services++;
1267         }
1268
1269         return num_services;
1270 }
1271
1272 Value HostsTable::NumServicesPendingAccessor(const Value& row)
1273 {
1274         Host::Ptr host = static_cast<Host::Ptr>(row);
1275
1276         if (!host)
1277                 return Empty;
1278
1279         int num_services = 0;
1280
1281         for (const Service::Ptr& service : host->GetServices()) {
1282                 if (!service->GetLastCheckResult())
1283                         num_services++;
1284         }
1285
1286         return num_services;
1287 }
1288
1289 Value HostsTable::WorstServiceHardStateAccessor(const Value& row)
1290 {
1291         Host::Ptr host = static_cast<Host::Ptr>(row);
1292
1293         if (!host)
1294                 return Empty;
1295
1296         Value worst_service = ServiceOK;
1297
1298         for (const Service::Ptr& service : host->GetServices()) {
1299                 if (service->GetStateType() == StateTypeHard) {
1300                         if (service->GetState() > worst_service)
1301                                 worst_service = service->GetState();
1302                 }
1303         }
1304
1305         return worst_service;
1306 }
1307
1308 Value HostsTable::NumServicesHardOkAccessor(const Value& row)
1309 {
1310         Host::Ptr host = static_cast<Host::Ptr>(row);
1311
1312         if (!host)
1313                 return Empty;
1314
1315         int num_services = 0;
1316
1317         for (const Service::Ptr& service : host->GetServices()) {
1318                 if (service->GetStateType() == StateTypeHard && service->GetState() == ServiceOK)
1319                         num_services++;
1320         }
1321
1322         return num_services;
1323 }
1324
1325 Value HostsTable::NumServicesHardWarnAccessor(const Value& row)
1326 {
1327         Host::Ptr host = static_cast<Host::Ptr>(row);
1328
1329         if (!host)
1330                 return Empty;
1331
1332         int num_services = 0;
1333
1334         for (const Service::Ptr& service : host->GetServices()) {
1335                 if (service->GetStateType() == StateTypeHard && service->GetState() == ServiceWarning)
1336                         num_services++;
1337         }
1338
1339         return num_services;
1340 }
1341
1342 Value HostsTable::NumServicesHardCritAccessor(const Value& row)
1343 {
1344         Host::Ptr host = static_cast<Host::Ptr>(row);
1345
1346         if (!host)
1347                 return Empty;
1348
1349         int num_services = 0;
1350
1351         for (const Service::Ptr& service : host->GetServices()) {
1352                 if (service->GetStateType() == StateTypeHard && service->GetState() == ServiceCritical)
1353                         num_services++;
1354         }
1355
1356         return num_services;
1357 }
1358
1359 Value HostsTable::NumServicesHardUnknownAccessor(const Value& row)
1360 {
1361         Host::Ptr host = static_cast<Host::Ptr>(row);
1362
1363         if (!host)
1364                 return Empty;
1365
1366         int num_services = 0;
1367
1368         for (const Service::Ptr& service : host->GetServices()) {
1369                 if (service->GetStateType() == StateTypeHard && service->GetState() == ServiceUnknown)
1370                         num_services++;
1371         }
1372
1373         return num_services;
1374 }
1375
1376 Value HostsTable::HardStateAccessor(const Value& row)
1377 {
1378         Host::Ptr host = static_cast<Host::Ptr>(row);
1379
1380         if (!host)
1381                 return Empty;
1382
1383         if (host->GetState() == HostUp)
1384                 return HostUp;
1385         else if (host->GetStateType() == StateTypeHard)
1386                 return host->GetState();
1387
1388         return host->GetLastHardState();
1389 }
1390
1391 Value HostsTable::StalenessAccessor(const Value& row)
1392 {
1393         Host::Ptr host = static_cast<Host::Ptr>(row);
1394
1395         if (!host)
1396                 return Empty;
1397
1398         if (host->HasBeenChecked() && host->GetLastCheck() > 0)
1399                 return (Utility::GetTime() - host->GetLastCheck()) / (host->GetCheckInterval() * 3600);
1400
1401         return 0.0;
1402 }
1403
1404 Value HostsTable::GroupsAccessor(const Value& row)
1405 {
1406         Host::Ptr host = static_cast<Host::Ptr>(row);
1407
1408         if (!host)
1409                 return Empty;
1410
1411         Array::Ptr groups = host->GetGroups();
1412
1413         if (!groups)
1414                 return Empty;
1415
1416         return groups;
1417 }
1418
1419 Value HostsTable::ContactGroupsAccessor(const Value& row)
1420 {
1421         Host::Ptr host = static_cast<Host::Ptr>(row);
1422
1423         if (!host)
1424                 return Empty;
1425
1426         Array::Ptr contactgroup_names = new Array();
1427
1428         for (const UserGroup::Ptr& usergroup : CompatUtility::GetCheckableNotificationUserGroups(host)) {
1429                 contactgroup_names->Add(usergroup->GetName());
1430         }
1431
1432         return contactgroup_names;
1433 }
1434
1435 Value HostsTable::ServicesAccessor(const Value& row)
1436 {
1437         Host::Ptr host = static_cast<Host::Ptr>(row);
1438
1439         if (!host)
1440                 return Empty;
1441
1442         std::vector<Service::Ptr> rservices = host->GetServices();
1443
1444         Array::Ptr services = new Array();
1445         services->Reserve(rservices.size());
1446
1447         for (const Service::Ptr& service : rservices) {
1448                 services->Add(service->GetShortName());
1449         }
1450
1451         return services;
1452 }
1453
1454 Value HostsTable::ServicesWithStateAccessor(const Value& row)
1455 {
1456         Host::Ptr host = static_cast<Host::Ptr>(row);
1457
1458         if (!host)
1459                 return Empty;
1460
1461         std::vector<Service::Ptr> rservices = host->GetServices();
1462
1463         Array::Ptr services = new Array();
1464         services->Reserve(rservices.size());
1465
1466         for (const Service::Ptr& service : rservices) {
1467                 Array::Ptr svc_add = new Array();
1468
1469                 svc_add->Add(service->GetShortName());
1470                 svc_add->Add(service->GetState());
1471                 svc_add->Add(service->HasBeenChecked() ? 1 : 0);
1472                 services->Add(svc_add);
1473         }
1474
1475         return services;
1476 }
1477
1478 Value HostsTable::ServicesWithInfoAccessor(const Value& row)
1479 {
1480         Host::Ptr host = static_cast<Host::Ptr>(row);
1481
1482         if (!host)
1483                 return Empty;
1484
1485         std::vector<Service::Ptr> rservices = host->GetServices();
1486
1487         Array::Ptr services = new Array();
1488         services->Reserve(rservices.size());
1489
1490         for (const Service::Ptr& service : rservices) {
1491                 Array::Ptr svc_add = new Array();
1492
1493                 svc_add->Add(service->GetShortName());
1494                 svc_add->Add(service->GetState());
1495                 svc_add->Add(service->HasBeenChecked() ? 1 : 0);
1496
1497                 String output;
1498                 CheckResult::Ptr cr = service->GetLastCheckResult();
1499
1500                 if (cr)
1501                         output = CompatUtility::GetCheckResultOutput(cr);
1502
1503                 svc_add->Add(output);
1504                 services->Add(svc_add);
1505         }
1506
1507         return services;
1508 }
1509
1510 Value HostsTable::CheckSourceAccessor(const Value& row)
1511 {
1512         Host::Ptr host = static_cast<Host::Ptr>(row);
1513
1514         if (!host)
1515                 return Empty;
1516
1517         CheckResult::Ptr cr = host->GetLastCheckResult();
1518
1519         if (cr)
1520                 return cr->GetCheckSource();
1521
1522         return Empty;
1523 }
1524
1525 Value HostsTable::IsReachableAccessor(const Value& row)
1526 {
1527         Host::Ptr host = static_cast<Host::Ptr>(row);
1528
1529         if (!host)
1530                 return Empty;
1531
1532         return host->IsReachable();
1533 }
1534
1535 Value HostsTable::OriginalAttributesAccessor(const Value& row)
1536 {
1537         Host::Ptr host = static_cast<Host::Ptr>(row);
1538
1539         if (!host)
1540                 return Empty;
1541
1542         return JsonEncode(host->GetOriginalAttributes());
1543 }