granicus.if.org Git - icinga2/blob - lib/checker/checkercomponent.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 "checker/checkercomponent.hpp"
  21 #include "checker/checkercomponent-ti.cpp"
  22 #include "icinga/icingaapplication.hpp"
  23 #include "icinga/cib.hpp"
  24 #include "remote/apilistener.hpp"
  25 #include "base/configtype.hpp"
  26 #include "base/objectlock.hpp"
  27 #include "base/utility.hpp"
  28 #include "base/perfdatavalue.hpp"
  29 #include "base/logger.hpp"
  30 #include "base/exception.hpp"
  31 #include "base/convert.hpp"
  32 #include "base/statsfunction.hpp"
  33
  34 using namespace icinga;
  35
  36 REGISTER_TYPE(CheckerComponent);
  37
  38 REGISTER_STATSFUNCTION(CheckerComponent, &CheckerComponent::StatsFunc);
  39
  40 void CheckerComponent::StatsFunc(const Dictionary::Ptr& status, const Array::Ptr& perfdata)
  41 {
  42         DictionaryData nodes;
  43
  44         for (const CheckerComponent::Ptr& checker : ConfigType::GetObjectsByType<CheckerComponent>()) {
  45                 unsigned long idle = checker->GetIdleCheckables();
  46                 unsigned long pending = checker->GetPendingCheckables();
  47
  48                 nodes.emplace_back(checker->GetName(), new Dictionary({
  49                         { "idle", idle },
  50                         { "pending", pending }
  51                 }));
  52
  53                 String perfdata_prefix = "checkercomponent_" + checker->GetName() + "_";
  54                 perfdata->Add(new PerfdataValue(perfdata_prefix + "idle", Convert::ToDouble(idle)));
  55                 perfdata->Add(new PerfdataValue(perfdata_prefix + "pending", Convert::ToDouble(pending)));
  56         }
  57
  58         status->Set("checkercomponent", new Dictionary(std::move(nodes)));
  59 }
  60
  61 void CheckerComponent::OnConfigLoaded()
  62 {
  63         ConfigObject::OnActiveChanged.connect(std::bind(&CheckerComponent::ObjectHandler, this, _1));
  64         ConfigObject::OnPausedChanged.connect(std::bind(&CheckerComponent::ObjectHandler, this, _1));
  65
  66         Checkable::OnNextCheckChanged.connect(std::bind(&CheckerComponent::NextCheckChangedHandler, this, _1));
  67 }
  68
  69 void CheckerComponent::Start(bool runtimeCreated)
  70 {
  71         ObjectImpl<CheckerComponent>::Start(runtimeCreated);
  72
  73         Log(LogInformation, "CheckerComponent")
  74                 << "'" << GetName() << "' started.";
  75
  76
  77         m_Thread = std::thread(std::bind(&CheckerComponent::CheckThreadProc, this));
  78
  79         m_ResultTimer = new Timer();
  80         m_ResultTimer->SetInterval(5);
  81         m_ResultTimer->OnTimerExpired.connect(std::bind(&CheckerComponent::ResultTimerHandler, this));
  82         m_ResultTimer->Start();
  83 }
  84
  85 void CheckerComponent::Stop(bool runtimeRemoved)
  86 {
  87         Log(LogInformation, "CheckerComponent")
  88                 << "'" << GetName() << "' stopped.";
  89
  90         {
  91                 boost::mutex::scoped_lock lock(m_Mutex);
  92                 m_Stopped = true;
  93                 m_CV.notify_all();
  94         }
  95
  96         m_ResultTimer->Stop();
  97         m_Thread.join();
  98
  99         ObjectImpl<CheckerComponent>::Stop(runtimeRemoved);
 100 }
 101
 102 void CheckerComponent::CheckThreadProc()
 103 {
 104         Utility::SetThreadName("Check Scheduler");
 105
 106         boost::mutex::scoped_lock lock(m_Mutex);
 107
 108         for (;;) {
 109                 typedef boost::multi_index::nth_index<CheckableSet, 1>::type CheckTimeView;
 110                 CheckTimeView& idx = boost::get<1>(m_IdleCheckables);
 111
 112                 while (idx.begin() == idx.end() && !m_Stopped)
 113                         m_CV.wait(lock);
 114
 115                 if (m_Stopped)
 116                         break;
 117
 118                 auto it = idx.begin();
 119                 CheckableScheduleInfo csi = *it;
 120
 121                 double wait = csi.NextCheck - Utility::GetTime();
 122
 123                 if (Checkable::GetPendingChecks() >= GetConcurrentChecks())
 124                         wait = 0.5;
 125
 126                 if (wait > 0) {
 127                         /* Wait for the next check. */
 128                         m_CV.timed_wait(lock, boost::posix_time::milliseconds(long(wait * 1000)));
 129
 130                         continue;
 131                 }
 132
 133                 Checkable::Ptr checkable = csi.Object;
 134
 135                 m_IdleCheckables.erase(checkable);
 136
 137                 bool forced = checkable->GetForceNextCheck();
 138                 bool check = true;
 139
 140                 if (!forced) {
 141                         if (!checkable->IsReachable(DependencyCheckExecution)) {
 142                                 Log(LogNotice, "CheckerComponent")
 143                                         << "Skipping check for object '" << checkable->GetName() << "': Dependency failed.";
 144                                 check = false;
 145                         }
 146
 147                         Host::Ptr host;
 148                         Service::Ptr service;
 149                         tie(host, service) = GetHostService(checkable);
 150
 151                         if (host && !service && (!checkable->GetEnableActiveChecks() || !IcingaApplication::GetInstance()->GetEnableHostChecks())) {
 152                                 Log(LogNotice, "CheckerComponent")
 153                                         << "Skipping check for host '" << host->GetName() << "': active host checks are disabled";
 154                                 check = false;
 155                         }
 156                         if (host && service && (!checkable->GetEnableActiveChecks() || !IcingaApplication::GetInstance()->GetEnableServiceChecks())) {
 157                                 Log(LogNotice, "CheckerComponent")
 158                                         << "Skipping check for service '" << service->GetName() << "': active service checks are disabled";
 159                                 check = false;
 160                         }
 161
 162                         TimePeriod::Ptr tp = checkable->GetCheckPeriod();
 163
 164                         if (tp && !tp->IsInside(Utility::GetTime())) {
 165                                 Log(LogNotice, "CheckerComponent")
 166                                         << "Skipping check for object '" << checkable->GetName()
 167                                         << "': not in check period '" << tp->GetName() << "'";
 168                                 check = false;
 169                         }
 170                 }
 171
 172                 /* reschedule the checkable if checks are disabled */
 173                 if (!check) {
 174                         m_IdleCheckables.insert(GetCheckableScheduleInfo(checkable));
 175                         lock.unlock();
 176
 177                         Log(LogDebug, "CheckerComponent")
 178                                 << "Checks for checkable '" << checkable->GetName() << "' are disabled. Rescheduling check.";
 179
 180                         checkable->UpdateNextCheck();
 181
 182                         lock.lock();
 183
 184                         continue;
 185                 }
 186
 187
 188                 csi = GetCheckableScheduleInfo(checkable);
 189
 190                 Log(LogDebug, "CheckerComponent")
 191                         << "Scheduling info for checkable '" << checkable->GetName() << "' ("
 192                         << Utility::FormatDateTime("%Y-%m-%d %H:%M:%S %z", checkable->GetNextCheck()) << "): Object '"
 193                         << csi.Object->GetName() << "', Next Check: "
 194                         << Utility::FormatDateTime("%Y-%m-%d %H:%M:%S %z", csi.NextCheck) << "(" << csi.NextCheck << ").";
 195
 196                 m_PendingCheckables.insert(csi);
 197
 198                 lock.unlock();
 199
 200                 if (forced) {
 201                         ObjectLock olock(checkable);
 202                         checkable->SetForceNextCheck(false);
 203                 }
 204
 205                 Log(LogDebug, "CheckerComponent")
 206                         << "Executing check for '" << checkable->GetName() << "'";
 207
 208                 Checkable::IncreasePendingChecks();
 209
 210                 Utility::QueueAsyncCallback(std::bind(&CheckerComponent::ExecuteCheckHelper, CheckerComponent::Ptr(this), checkable));
 211
 212                 lock.lock();
 213         }
 214 }
 215
 216 void CheckerComponent::ExecuteCheckHelper(const Checkable::Ptr& checkable)
 217 {
 218         try {
 219                 checkable->ExecuteCheck();
 220         } catch (const std::exception& ex) {
 221                 CheckResult::Ptr cr = new CheckResult();
 222                 cr->SetState(ServiceUnknown);
 223
 224                 String output = "Exception occurred while checking '" + checkable->GetName() + "': " + DiagnosticInformation(ex);
 225                 cr->SetOutput(output);
 226
 227                 double now = Utility::GetTime();
 228                 cr->SetScheduleStart(now);
 229                 cr->SetScheduleEnd(now);
 230                 cr->SetExecutionStart(now);
 231                 cr->SetExecutionEnd(now);
 232
 233                 checkable->ProcessCheckResult(cr);
 234
 235                 Log(LogCritical, "checker", output);
 236         }
 237
 238         Checkable::DecreasePendingChecks();
 239
 240         {
 241                 boost::mutex::scoped_lock lock(m_Mutex);
 242
 243                 /* remove the object from the list of pending objects; if it's not in the
 244                  * list this was a manual (i.e. forced) check and we must not re-add the
 245                  * object to the list because it's already there. */
 246                 auto it = m_PendingCheckables.find(checkable);
 247
 248                 if (it != m_PendingCheckables.end()) {
 249                         m_PendingCheckables.erase(it);
 250
 251                         if (checkable->IsActive())
 252                                 m_IdleCheckables.insert(GetCheckableScheduleInfo(checkable));
 253
 254                         m_CV.notify_all();
 255                 }
 256         }
 257
 258         Log(LogDebug, "CheckerComponent")
 259                 << "Check finished for object '" << checkable->GetName() << "'";
 260 }
 261
 262 void CheckerComponent::ResultTimerHandler()
 263 {
 264         std::ostringstream msgbuf;
 265
 266         {
 267                 boost::mutex::scoped_lock lock(m_Mutex);
 268
 269                 msgbuf << "Pending checkables: " << m_PendingCheckables.size() << "; Idle checkables: " << m_IdleCheckables.size() << "; Checks/s: "
 270                         << (CIB::GetActiveHostChecksStatistics(60) + CIB::GetActiveServiceChecksStatistics(60)) / 60.0;
 271         }
 272
 273         Log(LogNotice, "CheckerComponent", msgbuf.str());
 274 }
 275
 276 void CheckerComponent::ObjectHandler(const ConfigObject::Ptr& object)
 277 {
 278         Checkable::Ptr checkable = dynamic_pointer_cast<Checkable>(object);
 279
 280         if (!checkable)
 281                 return;
 282
 283         Zone::Ptr zone = Zone::GetByName(checkable->GetZoneName());
 284         bool same_zone = (!zone || Zone::GetLocalZone() == zone);
 285
 286         {
 287                 boost::mutex::scoped_lock lock(m_Mutex);
 288
 289                 if (object->IsActive() && !object->IsPaused() && same_zone) {
 290                         if (m_PendingCheckables.find(checkable) != m_PendingCheckables.end())
 291                                 return;
 292
 293                         m_IdleCheckables.insert(GetCheckableScheduleInfo(checkable));
 294                 } else {
 295                         m_IdleCheckables.erase(checkable);
 296                         m_PendingCheckables.erase(checkable);
 297                 }
 298
 299                 m_CV.notify_all();
 300         }
 301 }
 302
 303 CheckableScheduleInfo CheckerComponent::GetCheckableScheduleInfo(const Checkable::Ptr& checkable)
 304 {
 305         CheckableScheduleInfo csi;
 306         csi.Object = checkable;
 307         csi.NextCheck = checkable->GetNextCheck();
 308         return csi;
 309 }
 310
 311 void CheckerComponent::NextCheckChangedHandler(const Checkable::Ptr& checkable)
 312 {
 313         boost::mutex::scoped_lock lock(m_Mutex);
 314
 315         /* remove and re-insert the object from the set in order to force an index update */
 316         typedef boost::multi_index::nth_index<CheckableSet, 0>::type CheckableView;
 317         CheckableView& idx = boost::get<0>(m_IdleCheckables);
 318
 319         auto it = idx.find(checkable);
 320
 321         if (it == idx.end())
 322                 return;
 323
 324         idx.erase(checkable);
 325
 326         CheckableScheduleInfo csi = GetCheckableScheduleInfo(checkable);
 327         idx.insert(csi);
 328
 329         m_CV.notify_all();
 330 }
 331
 332 unsigned long CheckerComponent::GetIdleCheckables()
 333 {
 334         boost::mutex::scoped_lock lock(m_Mutex);
 335
 336         return m_IdleCheckables.size();
 337 }
 338
 339 unsigned long CheckerComponent::GetPendingCheckables()
 340 {
 341         boost::mutex::scoped_lock lock(m_Mutex);
 342
 343         return m_PendingCheckables.size();
 344 }