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

   1 /******************************************************************************
   2  * Icinga 2                                                                   *
   3  * Copyright (C) 2012-2013 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/hostgroupstable.h"
  21 #include "icinga/hostgroup.h"
  22 #include "icinga/host.h"
  23 #include "icinga/service.h"
  24 #include "base/dynamictype.h"
  25 #include <boost/foreach.hpp>
  26
  27 using namespace icinga;
  28
  29 HostGroupsTable::HostGroupsTable(void)
  30 {
  31         AddColumns(this);
  32 }
  33
  34 void HostGroupsTable::AddColumns(Table *table, const String& prefix,
  35     const Column::ObjectAccessor& objectAccessor)
  36 {
  37         table->AddColumn(prefix + "name", Column(&HostGroupsTable::NameAccessor, objectAccessor));
  38         table->AddColumn(prefix + "alias", Column(&HostGroupsTable::AliasAccessor, objectAccessor));
  39         table->AddColumn(prefix + "notes", Column(&HostGroupsTable::NotesAccessor, objectAccessor));
  40         table->AddColumn(prefix + "notes_url", Column(&HostGroupsTable::NotesUrlAccessor, objectAccessor));
  41         table->AddColumn(prefix + "action_url", Column(&HostGroupsTable::ActionUrlAccessor, objectAccessor));
  42         table->AddColumn(prefix + "members", Column(&HostGroupsTable::MembersAccessor, objectAccessor));
  43         table->AddColumn(prefix + "members_with_state", Column(&HostGroupsTable::MembersWithStateAccessor, objectAccessor));
  44         table->AddColumn(prefix + "worst_host_state", Column(&HostGroupsTable::WorstHostStateAccessor, objectAccessor));
  45         table->AddColumn(prefix + "num_hosts", Column(&HostGroupsTable::NumHostsAccessor, objectAccessor));
  46         table->AddColumn(prefix + "num_hosts_pending", Column(&HostGroupsTable::NumHostsPendingAccessor, objectAccessor));
  47         table->AddColumn(prefix + "num_hosts_up", Column(&HostGroupsTable::NumHostsUpAccessor, objectAccessor));
  48         table->AddColumn(prefix + "num_hosts_down", Column(&HostGroupsTable::NumHostsDownAccessor, objectAccessor));
  49         table->AddColumn(prefix + "num_hosts_unreach", Column(&HostGroupsTable::NumHostsUnreachAccessor, objectAccessor));
  50         table->AddColumn(prefix + "num_services", Column(&HostGroupsTable::NumServicesAccessor, objectAccessor));
  51         table->AddColumn(prefix + "worst_services_state", Column(&HostGroupsTable::WorstServicesStateAccessor, objectAccessor));
  52         table->AddColumn(prefix + "num_services_pending", Column(&HostGroupsTable::NumServicesPendingAccessor, objectAccessor));
  53         table->AddColumn(prefix + "num_services_ok", Column(&HostGroupsTable::NumServicesOkAccessor, objectAccessor));
  54         table->AddColumn(prefix + "num_services_warn", Column(&HostGroupsTable::NumServicesWarnAccessor, objectAccessor));
  55         table->AddColumn(prefix + "num_services_crit", Column(&HostGroupsTable::NumServicesCritAccessor, objectAccessor));
  56         table->AddColumn(prefix + "num_services_unknown", Column(&HostGroupsTable::NumServicesUnknownAccessor, objectAccessor));
  57         table->AddColumn(prefix + "worst_service_hard_state", Column(&HostGroupsTable::WorstServiceHardStateAccessor, objectAccessor));
  58         table->AddColumn(prefix + "num_services_hard_ok", Column(&HostGroupsTable::NumServicesHardOkAccessor, objectAccessor));
  59         table->AddColumn(prefix + "num_services_hard_warn", Column(&HostGroupsTable::NumServicesHardWarnAccessor, objectAccessor));
  60         table->AddColumn(prefix + "num_services_hard_crit", Column(&HostGroupsTable::NumServicesHardCritAccessor, objectAccessor));
  61         table->AddColumn(prefix + "num_services_hard_unknown", Column(&HostGroupsTable::NumServicesHardUnknownAccessor, objectAccessor));
  62 }
  63
  64 String HostGroupsTable::GetName(void) const
  65 {
  66         return "hostgroups";
  67 }
  68
  69 void HostGroupsTable::FetchRows(const AddRowFunction& addRowFn)
  70 {
  71         BOOST_FOREACH(const HostGroup::Ptr& hg, DynamicType::GetObjects<HostGroup>()) {
  72                 addRowFn(hg);
  73         }
  74 }
  75
  76 Value HostGroupsTable::NameAccessor(const Value& row)
  77 {
  78         return static_cast<HostGroup::Ptr>(row)->GetName();
  79 }
  80
  81 Value HostGroupsTable::AliasAccessor(const Value& row)
  82 {
  83         return static_cast<HostGroup::Ptr>(row)->GetDisplayName();
  84 }
  85
  86 Value HostGroupsTable::NotesAccessor(const Value& row)
  87 {
  88         Dictionary::Ptr custom = static_cast<HostGroup::Ptr>(row)->GetCustom();
  89
  90         if (!custom)
  91                 return Empty;
  92
  93         return custom->Get("notes");
  94 }
  95
  96 Value HostGroupsTable::NotesUrlAccessor(const Value& row)
  97 {
  98         Dictionary::Ptr custom = static_cast<HostGroup::Ptr>(row)->GetCustom();
  99
 100         if (!custom)
 101                 return Empty;
 102
 103         return custom->Get("notes_url");
 104 }
 105
 106 Value HostGroupsTable::ActionUrlAccessor(const Value& row)
 107 {
 108         Dictionary::Ptr custom = static_cast<HostGroup::Ptr>(row)->GetCustom();
 109
 110         if (!custom)
 111                 return Empty;
 112
 113         return custom->Get("action_url");
 114 }
 115
 116 Value HostGroupsTable::MembersAccessor(const Value& row)
 117 {
 118         Array::Ptr members = make_shared<Array>();
 119
 120         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 121                 members->Add(host->GetName());
 122         }
 123
 124         return members;
 125 }
 126
 127 Value HostGroupsTable::MembersWithStateAccessor(const Value& row)
 128 {
 129         Array::Ptr members = make_shared<Array>();
 130
 131         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 132                 Array::Ptr member_state = make_shared<Array>();
 133                 member_state->Add(host->GetName());
 134                 member_state->Add(host->GetState());
 135                 members->Add(member_state);
 136         }
 137
 138         return members;
 139 }
 140
 141 Value HostGroupsTable::WorstHostStateAccessor(const Value& row)
 142 {
 143         int worst_host = HostUp;
 144
 145         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 146                 if (host->GetState() > worst_host)
 147                         worst_host = host->GetState();
 148         }
 149
 150         return worst_host;
 151 }
 152
 153 Value HostGroupsTable::NumHostsAccessor(const Value& row)
 154 {
 155         return static_cast<long>(static_cast<HostGroup::Ptr>(row)->GetMembers().size());
 156 }
 157
 158 Value HostGroupsTable::NumHostsPendingAccessor(const Value& row)
 159 {
 160         int num_hosts = 0;
 161
 162         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 163                 Service::Ptr hc = host->GetCheckService();
 164
 165                 /* no hostcheck service or no checkresult */
 166                 if (!hc || !hc->GetLastCheckResult())
 167                         num_hosts++;
 168         }
 169
 170         return num_hosts;
 171 }
 172
 173 Value HostGroupsTable::NumHostsUpAccessor(const Value& row)
 174 {
 175         int num_hosts = 0;
 176
 177         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 178                 if (host->GetState() == HostUp)
 179                         num_hosts++;
 180         }
 181
 182         return num_hosts;
 183 }
 184
 185 Value HostGroupsTable::NumHostsDownAccessor(const Value& row)
 186 {
 187         int num_hosts = 0;
 188
 189         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 190                 if (host->GetState() == HostDown)
 191                         num_hosts++;
 192         }
 193
 194         return num_hosts;
 195 }
 196
 197 Value HostGroupsTable::NumHostsUnreachAccessor(const Value& row)
 198 {
 199         int num_hosts = 0;
 200
 201         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 202                 if (host->GetState() == HostUnreachable)
 203                         num_hosts++;
 204         }
 205
 206         return num_hosts;
 207 }
 208
 209 Value HostGroupsTable::NumServicesAccessor(const Value& row)
 210 {
 211         int num_services = 0;
 212         HostGroup::Ptr hg = static_cast<HostGroup::Ptr>(row);
 213
 214         if (hg->GetMembers().size() == 0)
 215                 return 0;
 216
 217         BOOST_FOREACH(const Host::Ptr& host, hg->GetMembers()) {
 218                 num_services += host->GetServices().size();
 219         }
 220
 221         return num_services;
 222 }
 223
 224 Value HostGroupsTable::WorstServicesStateAccessor(const Value& row)
 225 {
 226         Value worst_service = StateOK;
 227
 228         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 229                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 230                         if (service->GetState() > worst_service)
 231                                 worst_service = service->GetState();
 232                 }
 233         }
 234
 235         return worst_service;
 236 }
 237
 238 Value HostGroupsTable::NumServicesPendingAccessor(const Value& row)
 239 {
 240         int num_services = 0;
 241
 242         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 243                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 244                         if (!service->GetLastCheckResult())
 245                                 num_services++;
 246                 }
 247         }
 248
 249         return num_services;
 250 }
 251
 252 Value HostGroupsTable::NumServicesOkAccessor(const Value& row)
 253 {
 254         int num_services = 0;
 255
 256         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 257                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 258                         if (service->GetState() == StateOK)
 259                                 num_services++;
 260                 }
 261         }
 262
 263         return num_services;
 264 }
 265
 266 Value HostGroupsTable::NumServicesWarnAccessor(const Value& row)
 267 {
 268         int num_services = 0;
 269
 270         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 271                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 272                         if (service->GetState() == StateWarning)
 273                                 num_services++;
 274                 }
 275         }
 276
 277         return num_services;
 278 }
 279
 280 Value HostGroupsTable::NumServicesCritAccessor(const Value& row)
 281 {
 282         int num_services = 0;
 283
 284         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 285                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 286                         if (service->GetState() == StateCritical)
 287                                 num_services++;
 288                 }
 289         }
 290
 291         return num_services;
 292 }
 293
 294 Value HostGroupsTable::NumServicesUnknownAccessor(const Value& row)
 295 {
 296         int num_services = 0;
 297
 298         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 299                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 300                         if (service->GetState() == StateUnknown)
 301                                 num_services++;
 302                 }
 303         }
 304
 305         return num_services;
 306 }
 307
 308 Value HostGroupsTable::WorstServiceHardStateAccessor(const Value& row)
 309 {
 310         Value worst_service = StateOK;
 311
 312         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 313                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 314                         if (service->GetStateType() == StateTypeHard) {
 315                                 if (service->GetState() > worst_service)
 316                                         worst_service = service->GetState();
 317                         }
 318                 }
 319         }
 320
 321         return worst_service;
 322 }
 323
 324 Value HostGroupsTable::NumServicesHardOkAccessor(const Value& row)
 325 {
 326         int num_services = 0;
 327
 328         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 329                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 330                         if (service->GetStateType() == StateTypeHard && service->GetState() == StateOK)
 331                                 num_services++;
 332                 }
 333         }
 334
 335         return num_services;
 336 }
 337
 338 Value HostGroupsTable::NumServicesHardWarnAccessor(const Value& row)
 339 {
 340         int num_services = 0;
 341
 342         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 343                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 344                         if (service->GetStateType() == StateTypeHard && service->GetState() == StateWarning)
 345                                 num_services++;
 346                 }
 347         }
 348
 349         return num_services;
 350 }
 351
 352 Value HostGroupsTable::NumServicesHardCritAccessor(const Value& row)
 353 {
 354         int num_services = 0;
 355
 356         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 357                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 358                         if (service->GetStateType() == StateTypeHard && service->GetState() == StateCritical)
 359                                 num_services++;
 360                 }
 361         }
 362
 363         return num_services;
 364 }
 365
 366 Value HostGroupsTable::NumServicesHardUnknownAccessor(const Value& row)
 367 {
 368         int num_services = 0;
 369
 370         BOOST_FOREACH(const Host::Ptr& host, static_cast<HostGroup::Ptr>(row)->GetMembers()) {
 371                 BOOST_FOREACH(const Service::Ptr& service, host->GetServices()) {
 372                         if (service->GetStateType() == StateTypeHard && service->GetState() == StateUnknown)
 373                                 num_services++;
 374                 }
 375         }
 376
 377         return num_services;
 378 }