Method InsertCheckableDependencies

lib/icingadb/icingadb-objects.cpp:1145–1309

* Inserts the dependency data for a Checkable object into the given Redis HMSETs and runtime updates. * * This function is responsible for serializing the in memory representation Checkable dependencies into * Redis HMSETs and runtime updates (if any) according to the Icinga DB schema. The serialized data consists * of the following Redis HMSETs: * - dependency:node: Contains dependency node

 * @param onlyDependencyGroup If set, only process dependency objects from this group.
 */
void IcingaDB::InsertCheckableDependencies(
	const Checkable::Ptr& checkable,
	std::map<RedisConnection::QueryArg, RedisConnection::Query>& hMSets,
	std::vector<Dictionary::Ptr>* runtimeUpdates,
	const DependencyGroup::Ptr& onlyDependencyGroup
)
{
	// Only generate a dependency node event if the Checkable is actually part of some dependency graph.
	// That's, it either depends on other Checkables or others depend on it, and in both cases, we have
	// to at least generate a dependency node entry for it.
	if (!checkable->HasAnyDependencies()) {
		return;
	}

	// First and foremost, generate a dependency node entry for the provided Checkable object and insert it into
	// the HMSETs map and if set, the `runtimeUpdates` vector.
	auto [host, service] = GetHostService(checkable);
	auto checkableId(GetObjectIdentifier(checkable));
	{
		Dictionary::Ptr data(new Dictionary{{"environment_id", m_EnvironmentId}, {"host_id", GetObjectIdentifier(host)}});
		if (service) {
			data->Set("service_id", checkableId);
		}

		AddDataToHmSets(hMSets, CONFIG_REDIS_KEY_PREFIX "dependency:node", checkableId, data);
		if (runtimeUpdates) {
			AddObjectDataToRuntimeUpdates(*runtimeUpdates, checkableId, CONFIG_REDIS_KEY_PREFIX "dependency:node", data);
		}
	}

	// If `onlyDependencyGroup` is provided, process the dependencies only from that group; otherwise,
	// retrieve all the dependency groups that the Checkable object is part of.
	std::vector<DependencyGroup::Ptr> dependencyGroups{onlyDependencyGroup};
	if (!onlyDependencyGroup) {
		dependencyGroups = checkable->GetDependencyGroups();
	}

	for (auto& dependencyGroup : dependencyGroups) {
		String edgeFromNodeId(checkableId);
		bool syncSharedEdgeState(false);

		if (!dependencyGroup->IsRedundancyGroup()) {
			// Non-redundant dependency groups are just placeholders and never get synced to Redis, thus just figure
			// out whether we have to sync the shared edge state. For runtime updates the states are sent via the
			// UpdateDependenciesState() method, thus we don't have to sync them here.
			syncSharedEdgeState = !runtimeUpdates && m_DumpedGlobals.DependencyGroup.IsNew(dependencyGroup->GetCompositeKey());
		} else {
			auto redundancyGroupId(HashValue(new Array{m_EnvironmentId, dependencyGroup->GetCompositeKey()}));
			dependencyGroup->SetIcingaDBIdentifier(redundancyGroupId);

			edgeFromNodeId = redundancyGroupId;

			// During the initial config sync, multiple children can depend on the same redundancy group, sync it only
			// the first time it is encountered. Though, if this is a runtime update, we have to re-serialize and sync
			// the redundancy group unconditionally, as we don't know whether it was already synced or the context that
			// triggered this update.
			if (runtimeUpdates || m_DumpedGlobals.DependencyGroup.IsNew(redundancyGroupId)) {
				Dictionary::Ptr groupData(new Dictionary{