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