Method GetCompositeKey

lib/icinga/dependency-group.cpp:286–310

* Retrieve the unique composite key of the current dependency group. * * The composite key consists of some unique data of the group members, and should be used to generate * a unique deterministic hash for the dependency group. Additionally, for explicitly configured redundancy * groups, the non-unique dependency group name is also included on top of the composite keys. * * @return - Return

 * @return - Returns the composite key of the current dependency group.
 */
String DependencyGroup::GetCompositeKey()
{
	// This a copy of the CompositeKeyType definition but with the String type instead of Checkable* and TimePeriod*.
	// This is because we need to produce a deterministic value from the composite key after each restart and that's
	// not achievable using pointers.
	using StringTuple = std::tuple<String, String, int, bool>;
	std::vector<StringTuple> compositeKeys;
	for (auto& [compositeKey, _] : m_Members) {
		auto [parent, tp, stateFilter, ignoreSoftStates] = compositeKey;
		compositeKeys.emplace_back(parent->GetName(), tp ? tp->GetName() : "", stateFilter, ignoreSoftStates);
	}

	// IMPORTANT: The order of the composite keys must be sorted to ensure the deterministic hash value.
	std::sort(compositeKeys.begin(), compositeKeys.end());

	Array::Ptr data(new Array{GetRedundancyGroupName()});
	for (auto& compositeKey : compositeKeys) {
		// std::apply is used to unpack the composite key tuple and add its elements to the data array.
		// It's like manually expanding the tuple into x variables and then adding them one by one to the array.
		// See https://en.cppreference.com/w/cpp/language/fold for more information.
		std::apply([&data](auto&&... args) { (data->Add(std::move(args)), ...); }, std::move(compositeKey));
	}

	return PackObject(data);
}

/**
 * Retrieve the state of the current dependency group.