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

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