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

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