granicus.if.org Git - icinga2/blob - lib/icinga/checkable-dependency.cpp

   1 /* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
   2
   3 #include "icinga/service.hpp"
   4 #include "icinga/dependency.hpp"
   5 #include "base/logger.hpp"
   6
   7 using namespace icinga;
   8
   9 void Checkable::AddDependency(const Dependency::Ptr& dep)
  10 {
  11         boost::mutex::scoped_lock lock(m_DependencyMutex);
  12         m_Dependencies.insert(dep);
  13 }
  14
  15 void Checkable::RemoveDependency(const Dependency::Ptr& dep)
  16 {
  17         boost::mutex::scoped_lock lock(m_DependencyMutex);
  18         m_Dependencies.erase(dep);
  19 }
  20
  21 std::vector<Dependency::Ptr> Checkable::GetDependencies() const
  22 {
  23         boost::mutex::scoped_lock lock(m_DependencyMutex);
  24         return std::vector<Dependency::Ptr>(m_Dependencies.begin(), m_Dependencies.end());
  25 }
  26
  27 void Checkable::AddReverseDependency(const Dependency::Ptr& dep)
  28 {
  29         boost::mutex::scoped_lock lock(m_DependencyMutex);
  30         m_ReverseDependencies.insert(dep);
  31 }
  32
  33 void Checkable::RemoveReverseDependency(const Dependency::Ptr& dep)
  34 {
  35         boost::mutex::scoped_lock lock(m_DependencyMutex);
  36         m_ReverseDependencies.erase(dep);
  37 }
  38
  39 std::vector<Dependency::Ptr> Checkable::GetReverseDependencies() const
  40 {
  41         boost::mutex::scoped_lock lock(m_DependencyMutex);
  42         return std::vector<Dependency::Ptr>(m_ReverseDependencies.begin(), m_ReverseDependencies.end());
  43 }
  44
  45 bool Checkable::IsReachable(DependencyType dt, Dependency::Ptr *failedDependency, int rstack) const
  46 {
  47         /* Anything greater than 256 causes recursion bus errors. */
  48         int limit = 256;
  49
  50         if (rstack > limit) {
  51                 Log(LogWarning, "Checkable")
  52                         << "Too many nested dependencies (>" << limit << ") for checkable '" << GetName() << "': Dependency failed.";
  53
  54                 return false;
  55         }
  56
  57         for (const Checkable::Ptr& checkable : GetParents()) {
  58                 if (!checkable->IsReachable(dt, failedDependency, rstack + 1))
  59                         return false;
  60         }
  61
  62         /* implicit dependency on host if this is a service */
  63         const auto *service = dynamic_cast<const Service *>(this);
  64         if (service && (dt == DependencyState || dt == DependencyNotification)) {
  65                 Host::Ptr host = service->GetHost();
  66
  67                 if (host && host->GetState() != HostUp && host->GetStateType() == StateTypeHard) {
  68                         if (failedDependency)
  69                                 *failedDependency = nullptr;
  70
  71                         return false;
  72                 }
  73         }
  74
  75         for (const Dependency::Ptr& dep : GetDependencies()) {
  76                 if (!dep->IsAvailable(dt)) {
  77                         if (failedDependency)
  78                                 *failedDependency = dep;
  79
  80                         return false;
  81                 }
  82         }
  83
  84         if (failedDependency)
  85                 *failedDependency = nullptr;
  86
  87         return true;
  88 }
  89
  90 std::set<Checkable::Ptr> Checkable::GetParents() const
  91 {
  92         std::set<Checkable::Ptr> parents;
  93
  94         for (const Dependency::Ptr& dep : GetDependencies()) {
  95                 Checkable::Ptr parent = dep->GetParent();
  96
  97                 if (parent && parent.get() != this)
  98                         parents.insert(parent);
  99         }
 100
 101         return parents;
 102 }
 103
 104 std::set<Checkable::Ptr> Checkable::GetChildren() const
 105 {
 106         std::set<Checkable::Ptr> parents;
 107
 108         for (const Dependency::Ptr& dep : GetReverseDependencies()) {
 109                 Checkable::Ptr service = dep->GetChild();
 110
 111                 if (service && service.get() != this)
 112                         parents.insert(service);
 113         }
 114
 115         return parents;
 116 }
 117
 118 std::set<Checkable::Ptr> Checkable::GetAllChildren() const
 119 {
 120         std::set<Checkable::Ptr> children = GetChildren();
 121
 122         GetAllChildrenInternal(children, 0);
 123
 124         return children;
 125 }
 126
 127 void Checkable::GetAllChildrenInternal(std::set<Checkable::Ptr>& children, int level) const
 128 {
 129         if (level > 32)
 130                 return;
 131
 132         std::set<Checkable::Ptr> localChildren;
 133
 134         for (const Checkable::Ptr& checkable : children) {
 135                 std::set<Checkable::Ptr> cChildren = checkable->GetChildren();
 136
 137                 if (!cChildren.empty()) {
 138                         GetAllChildrenInternal(cChildren, level + 1);
 139                         localChildren.insert(cChildren.begin(), cChildren.end());
 140                 }
 141
 142                 localChildren.insert(checkable);
 143         }
 144
 145         children.insert(localChildren.begin(), localChildren.end());
 146 }