Method GetState

lib/icinga/dependency-state.cpp:85–126

* Retrieve the state of the given dependency group. * * The state of the dependency group is determined based on the state of the parent Checkables and dependency objects * of the group. A dependency group is considered unreachable when none of the parent Checkables is reachable. However, * a dependency group may still be marked as failed even when it has reachable parent Checkables, but an un

 * @return - Returns the state of the current dependency group.
 */
DependencyGroup::State DependencyStateChecker::GetState(const DependencyGroup::ConstPtr& group, const Checkable* child, int rstack)
{
	using State = DependencyGroup::State;

	auto dependencies(group->GetDependenciesForChild(child));
	size_t reachable = 0, available = 0;

	for (const auto& dependency : dependencies) {
		if (IsReachable(dependency->GetParent(), rstack)) {
			reachable++;

			// Only reachable parents are considered for availability. If they are unreachable and checks are
			// disabled, they could be incorrectly treated as available otherwise.
			if (dependency->IsAvailable(m_DependencyType)) {
				available++;
			}
		}
	}

	if (group->IsRedundancyGroup()) {
		// The state of a redundancy group is determined by the best state of any parent. If any parent ist reachable,
		// the redundancy group is reachable, analogously for availability.
		if (reachable == 0) {
			return State::Unreachable;
		} else if (available == 0) {
			return State::Failed;
		} else {
			return State::Ok;
		}
	} else {
		// For dependencies without a redundancy group, dependencies.size() will be 1 in almost all cases. It will only
		// contain more elements if there are duplicate dependency config objects between two checkables. In this case,
		// all of them have to be reachable/available as they don't provide redundancy.
		if (reachable < dependencies.size()) {
			return State::Unreachable;
		} else if (available < dependencies.size()) {
			return State::Failed;
		} else {
			return State::Ok;
		}
	}
}