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

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