Manages dependencies between health checks as a DAG. More...

#include <health_dependency_graph.h>

Collaboration diagram for kcenon::common::interfaces::health_dependency_graph:

Public Member Functions
	health_dependency_graph ()=default

	~health_dependency_graph ()=default

	health_dependency_graph (const health_dependency_graph &)=delete

health_dependency_graph &	operator= (const health_dependency_graph &)=delete

	health_dependency_graph (health_dependency_graph &&)=delete

health_dependency_graph &	operator= (health_dependency_graph &&)=delete

Result< bool >	add_node (const std::string &name, std::shared_ptr< health_check > check)
	Add a health check node to the graph.

Result< bool >	remove_node (const std::string &name)
	Remove a health check node from the graph.

Result< bool >	add_dependency (const std::string &dependent, const std::string &dependency)
	Add a dependency between two nodes.

Result< bool >	remove_dependency (const std::string &dependent, const std::string &dependency)
	Remove a dependency between two nodes.

std::set< std::string >	get_dependencies (const std::string &name) const
	Get all dependencies of a node.

std::set< std::string >	get_dependents (const std::string &name) const
	Get all nodes that depend on a given node.

bool	would_create_cycle (const std::string &from, const std::string &to) const
	Check if adding a dependency would create a cycle.

Result< std::vector< std::string > >	topological_sort () const
	Get topological sort of all nodes.

Result< health_check_result >	check_with_dependencies (const std::string &name)
	Execute health check with its dependencies.

std::set< std::string >	get_failure_impact (const std::string &name) const
	Get the impact of a node failure.

bool	has_node (const std::string &name) const
	Check if a node exists.

std::size_t	size () const
	Get number of nodes.

bool	empty () const
	Check if graph is empty.

void	clear ()
	Clear all nodes and dependencies.

std::vector< std::string >	get_all_nodes () const
	Get all node names.

Private Member Functions
bool	would_create_cycle_internal (const std::string &from, const std::string &to) const

Result< health_check_result >	check_with_dependencies_internal (const std::string &name, std::unordered_map< std::string, health_check_result > &results)

Private Attributes
std::unordered_map< std::string, std::shared_ptr< health_check > >	nodes_

std::unordered_map< std::string, std::set< std::string > >	dependencies_

std::unordered_map< std::string, std::set< std::string > >	dependents_

std::mutex	mutex_

Detailed Description

Manages dependencies between health checks as a DAG.

This class allows defining dependencies between health checks and executing them in the correct order. It supports cycle detection and topological sorting for proper execution order.

Example usage:

health_dependency_graph graph;
graph.add_node("database", db_check);
graph.add_node("cache", cache_check);
graph.add_node("api", api_check);
 
// api depends on database and cache
graph.add_dependency("api", "database");
graph.add_dependency("api", "cache");
 
// Execute in topological order
auto order = graph.topological_sort();
for (const auto& name : order.value()) {
    auto result = graph.check_with_dependencies(name);
}

Definition at line 54 of file health_dependency_graph.h.

Constructor & Destructor Documentation

◆ health_dependency_graph() [1/3]

kcenon::common::interfaces::health_dependency_graph::health_dependency_graph ( )

default

◆ ~health_dependency_graph()

kcenon::common::interfaces::health_dependency_graph::~health_dependency_graph ( )

default

◆ health_dependency_graph() [2/3]

kcenon::common::interfaces::health_dependency_graph::health_dependency_graph ( const health_dependency_graph & )

delete

◆ health_dependency_graph() [3/3]

kcenon::common::interfaces::health_dependency_graph::health_dependency_graph ( health_dependency_graph && )

delete

Member Function Documentation

◆ add_dependency()

Result< bool > kcenon::common::interfaces::health_dependency_graph::add_dependency	(	const std::string &	dependent,
		const std::string &	dependency )

inline

Add a dependency between two nodes.

Parameters

dependent	The node that depends on another
dependency	The node being depended upon

Returns: Result indicating success or failure

Definition at line 124 of file health_dependency_graph.h.

                                                                                         {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (nodes_.find(dependent) == nodes_.end()) {
            return {error_info{1, "Dependent node not found: " + dependent,
                               "health_dependency_graph"}};
        }
        if (nodes_.find(dependency) == nodes_.end()) {
            return {error_info{2, "Dependency node not found: " + dependency,
                               "health_dependency_graph"}};
        }
 
        if (would_create_cycle_internal(dependent, dependency)) {
            return {error_info{3,
                               "Adding dependency would create a cycle: " + dependent + " -> " +
                                   dependency,
                               "health_dependency_graph"}};
        }
 
        dependencies_[dependent].insert(dependency);
        dependents_[dependency].insert(dependent);
 
        return ok(true);
    }

References dependencies_, kcenon::common::interfaces::dependency, dependents_, mutex_, nodes_, kcenon::common::ok(), and would_create_cycle_internal().

Referenced by kcenon::common::interfaces::health_monitor::add_dependency().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_node()

Result< bool > kcenon::common::interfaces::health_dependency_graph::add_node	(	const std::string &	name,
		std::shared_ptr< health_check >	check )

inline

Add a health check node to the graph.

Parameters

name	Unique name for this node
check	Health check implementation

Returns: Result indicating success or failure

Definition at line 70 of file health_dependency_graph.h.

                                                                                    {
        if (name.empty()) {
            return {error_info{1, "Node name cannot be empty", "health_dependency_graph"}};
        }
        if (!check) {
            return {error_info{2, "Health check cannot be null", "health_dependency_graph"}};
        }
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (nodes_.find(name) != nodes_.end()) {
            return {error_info{3, "Node already exists: " + name, "health_dependency_graph"}};
        }
 
        nodes_[name] = std::move(check);
        dependencies_[name] = {};
        dependents_[name] = {};
 
        return ok(true);
    }

References dependencies_, dependents_, mutex_, nodes_, and kcenon::common::ok().

Referenced by kcenon::common::interfaces::health_monitor::register_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_with_dependencies()

Result< health_check_result > kcenon::common::interfaces::health_dependency_graph::check_with_dependencies ( const std::string & name )

inline

Execute health check with its dependencies.

Parameters

name	Name of the node to check

Returns: Result containing the health check result or error

This method first checks all dependencies recursively. If any dependency fails with unhealthy status, the dependent check is marked as unhealthy without executing it.

Definition at line 271 of file health_dependency_graph.h.

                                                                               {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto node_it = nodes_.find(name);
        if (node_it == nodes_.end()) {
            return {error_info{1, "Node not found: " + name, "health_dependency_graph"}};
        }
 
        std::unordered_map<std::string, health_check_result> results;
        return check_with_dependencies_internal(name, results);
    }

References check_with_dependencies_internal(), mutex_, and nodes_.

Referenced by kcenon::common::interfaces::health_monitor::check(), and kcenon::common::interfaces::health_monitor::refresh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_with_dependencies_internal()

Result< health_check_result > kcenon::common::interfaces::health_dependency_graph::check_with_dependencies_internal	(	const std::string &	name,
		std::unordered_map< std::string, health_check_result > &	results )

inlineprivate

Definition at line 400 of file health_dependency_graph.h.

                                                                   {
        // Check if already computed
        auto result_it = results.find(name);
        if (result_it != results.end()) {
            return ok(result_it->second);
        }
 
        auto node_it = nodes_.find(name);
        if (node_it == nodes_.end()) {
            return {error_info{1, "Node not found: " + name, "health_dependency_graph"}};
        }
 
        // Check all dependencies first
        bool dependency_failed = false;
        std::string failure_reason;
 
        for (const auto& dep : dependencies_[name]) {
            auto dep_result = check_with_dependencies_internal(dep, results);
            if (dep_result.is_err()) {
                dependency_failed = true;
                failure_reason = "Dependency check failed: " + dep;
                break;
            }
 
            if (dep_result.value().status == health_status::unhealthy) {
                dependency_failed = true;
                failure_reason = "Dependency unhealthy: " + dep;
                break;
            }
        }
 
        health_check_result result;
        if (dependency_failed) {
            result.status = health_status::unhealthy;
            result.message = failure_reason;
            result.metadata["skipped"] = "true";
            result.metadata["reason"] = "dependency_failure";
        } else {
            result = node_it->second->check();
        }
 
        results[name] = result;
        return ok(result);
    }

References check_with_dependencies_internal(), dependencies_, kcenon::common::interfaces::health_check_result::message, kcenon::common::interfaces::health_check_result::metadata, nodes_, kcenon::common::ok(), kcenon::common::interfaces::health_check_result::status, and kcenon::common::interfaces::unhealthy.

Referenced by check_with_dependencies(), and check_with_dependencies_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

void kcenon::common::interfaces::health_dependency_graph::clear ( )

inline

Clear all nodes and dependencies.

Definition at line 344 of file health_dependency_graph.h.

                 {
        std::lock_guard<std::mutex> lock(mutex_);
        nodes_.clear();
        dependencies_.clear();
        dependents_.clear();
    }

References dependencies_, dependents_, mutex_, and nodes_.

◆ empty()

bool kcenon::common::interfaces::health_dependency_graph::empty ( ) const

inlinenodiscard

Check if graph is empty.

Returns: true if no nodes exist

Definition at line 336 of file health_dependency_graph.h.

                                     {
        std::lock_guard<std::mutex> lock(mutex_);
        return nodes_.empty();
    }

References mutex_, and nodes_.

◆ get_all_nodes()

std::vector< std::string > kcenon::common::interfaces::health_dependency_graph::get_all_nodes ( ) const

inlinenodiscard

Get all node names.

Returns: Vector of all node names

Definition at line 355 of file health_dependency_graph.h.

                                                             {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<std::string> names;
        names.reserve(nodes_.size());
        for (const auto& [name, _] : nodes_) {
            names.push_back(name);
        }
        return names;
    }

References mutex_, and nodes_.

Referenced by kcenon::common::interfaces::health_monitor::get_check_names(), and kcenon::common::interfaces::health_monitor::refresh().

Here is the caller graph for this function:

◆ get_dependencies()

std::set< std::string > kcenon::common::interfaces::health_dependency_graph::get_dependencies ( const std::string & name ) const

inlinenodiscard

Get all dependencies of a node.

Parameters

name Node name

Returns: Set of dependency names

Definition at line 176 of file health_dependency_graph.h.

                                                                                  {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto it = dependencies_.find(name);
        if (it != dependencies_.end()) {
            return it->second;
        }
        return {};
    }

References dependencies_, and mutex_.

◆ get_dependents()

std::set< std::string > kcenon::common::interfaces::health_dependency_graph::get_dependents ( const std::string & name ) const

inlinenodiscard

Get all nodes that depend on a given node.

Parameters

name Node name

Returns: Set of dependent names

Definition at line 191 of file health_dependency_graph.h.

                                                                                {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto it = dependents_.find(name);
        if (it != dependents_.end()) {
            return it->second;
        }
        return {};
    }

References dependents_, and mutex_.

◆ get_failure_impact()

std::set< std::string > kcenon::common::interfaces::health_dependency_graph::get_failure_impact ( const std::string & name ) const

inlinenodiscard

Get the impact of a node failure.

Parameters

name	Name of the failed node

Returns: Set of all nodes that would be affected by this failure

Definition at line 288 of file health_dependency_graph.h.

                                                                                    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        std::set<std::string> impacted;
        std::queue<std::string> to_visit;
        to_visit.push(name);
 
        while (!to_visit.empty()) {
            std::string current = to_visit.front();
            to_visit.pop();
 
            auto it = dependents_.find(current);
            if (it != dependents_.end()) {
                for (const auto& dependent : it->second) {
                    if (impacted.find(dependent) == impacted.end()) {
                        impacted.insert(dependent);
                        to_visit.push(dependent);
                    }
                }
            }
        }
 
        return impacted;
    }

References dependents_, and mutex_.

◆ has_node()

bool kcenon::common::interfaces::health_dependency_graph::has_node ( const std::string & name ) const

inlinenodiscard

Check if a node exists.

Parameters

name Node name

Returns: true if node exists

Definition at line 318 of file health_dependency_graph.h.

                                                             {
        std::lock_guard<std::mutex> lock(mutex_);
        return nodes_.find(name) != nodes_.end();
    }

References mutex_, and nodes_.

Referenced by kcenon::common::interfaces::health_monitor::has_check().

Here is the caller graph for this function:

◆ operator=() [1/2]

health_dependency_graph & kcenon::common::interfaces::health_dependency_graph::operator= ( const health_dependency_graph & )

delete

◆ operator=() [2/2]

health_dependency_graph & kcenon::common::interfaces::health_dependency_graph::operator= ( health_dependency_graph && )

delete

◆ remove_dependency()

Result< bool > kcenon::common::interfaces::health_dependency_graph::remove_dependency	(	const std::string &	dependent,
		const std::string &	dependency )

inline

Remove a dependency between two nodes.

Parameters

dependent	The dependent node
dependency	The dependency node

Returns: Result indicating success or failure

Definition at line 155 of file health_dependency_graph.h.

                                                                                            {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (nodes_.find(dependent) == nodes_.end()) {
            return {error_info{1, "Dependent node not found: " + dependent,
                               "health_dependency_graph"}};
        }
 
        dependencies_[dependent].erase(dependency);
        if (nodes_.find(dependency) != nodes_.end()) {
            dependents_[dependency].erase(dependent);
        }
 
        return ok(true);
    }

References dependencies_, kcenon::common::interfaces::dependency, dependents_, mutex_, nodes_, and kcenon::common::ok().

Here is the call graph for this function:

◆ remove_node()

Result< bool > kcenon::common::interfaces::health_dependency_graph::remove_node ( const std::string & name )

inline

Remove a health check node from the graph.

Parameters

name	Name of the node to remove

Returns: Result indicating success or failure

Definition at line 96 of file health_dependency_graph.h.

                                                    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (nodes_.find(name) == nodes_.end()) {
            return {error_info{1, "Node not found: " + name, "health_dependency_graph"}};
        }
 
        // Remove all dependencies to/from this node
        for (const auto& dep : dependencies_[name]) {
            dependents_[dep].erase(name);
        }
        for (const auto& dep : dependents_[name]) {
            dependencies_[dep].erase(name);
        }
 
        nodes_.erase(name);
        dependencies_.erase(name);
        dependents_.erase(name);
 
        return ok(true);
    }

References dependencies_, dependents_, mutex_, nodes_, and kcenon::common::ok().

Referenced by kcenon::common::interfaces::health_monitor::unregister_check().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ size()

std::size_t kcenon::common::interfaces::health_dependency_graph::size ( ) const

inlinenodiscard

Get number of nodes.

Returns: Number of nodes in the graph

Definition at line 327 of file health_dependency_graph.h.

                                         {
        std::lock_guard<std::mutex> lock(mutex_);
        return nodes_.size();
    }

References mutex_, and nodes_.

◆ topological_sort()

Result< std::vector< std::string > > kcenon::common::interfaces::health_dependency_graph::topological_sort ( ) const

inlinenodiscard

Get topological sort of all nodes.

Returns: Result containing sorted node names or error if cycle exists

Definition at line 216 of file health_dependency_graph.h.

                                                                        {
        std::lock_guard<std::mutex> lock(mutex_);
 
        std::unordered_map<std::string, int> in_degree;
        for (const auto& [name, _] : nodes_) {
            in_degree[name] = 0;
        }
 
        for (const auto& [name, deps] : dependencies_) {
            for (const auto& dep : deps) {
                (void)dep;
            }
            in_degree[name] = static_cast<int>(deps.size());
        }
 
        std::queue<std::string> zero_in_degree;
        for (const auto& [name, degree] : in_degree) {
            if (degree == 0) {
                zero_in_degree.push(name);
            }
        }
 
        std::vector<std::string> result;
        result.reserve(nodes_.size());
 
        while (!zero_in_degree.empty()) {
            std::string current = zero_in_degree.front();
            zero_in_degree.pop();
            result.push_back(current);
 
            for (const auto& dependent : dependents_.at(current)) {
                --in_degree[dependent];
                if (in_degree[dependent] == 0) {
                    zero_in_degree.push(dependent);
                }
            }
        }
 
        if (result.size() != nodes_.size()) {
            return {error_info{1, "Cycle detected in dependency graph",
                               "health_dependency_graph"}};
        }
 
        return ok(result);
    }

References dependencies_, dependents_, mutex_, nodes_, and kcenon::common::ok().

Here is the call graph for this function:

◆ would_create_cycle()

bool kcenon::common::interfaces::health_dependency_graph::would_create_cycle	(	const std::string &	from,
		const std::string &	to ) const

inlinenodiscard

Check if adding a dependency would create a cycle.

Parameters

from	Source node
to	Target node

Returns: true if a cycle would be created

Definition at line 207 of file health_dependency_graph.h.

                                                                                            {
        std::lock_guard<std::mutex> lock(mutex_);
        return would_create_cycle_internal(from, to);
    }

References mutex_, and would_create_cycle_internal().

Here is the call graph for this function:

◆ would_create_cycle_internal()

bool kcenon::common::interfaces::health_dependency_graph::would_create_cycle_internal	(	const std::string &	from,
		const std::string &	to ) const

inlinenodiscardprivate

Definition at line 366 of file health_dependency_graph.h.

                                                                              {
        // Adding "from depends on to" edge
        // This would create a cycle if 'from' is reachable from 'to' via dependencies
        // i.e., to -> ... -> from already exists in the dependency chain
        std::unordered_set<std::string> visited;
        std::queue<std::string> queue;
        queue.push(to);
 
        while (!queue.empty()) {
            std::string current = queue.front();
            queue.pop();
 
            if (current == from) {
                return true;
            }
 
            if (visited.find(current) != visited.end()) {
                continue;
            }
            visited.insert(current);
 
            // Follow the dependencies of the current node
            auto it = dependencies_.find(current);
            if (it != dependencies_.end()) {
                for (const auto& dep : it->second) {
                    queue.push(dep);
                }
            }
        }
 
        return false;
    }

References dependencies_.

Referenced by add_dependency(), and would_create_cycle().

Here is the caller graph for this function:

Member Data Documentation

◆ dependencies_

std::unordered_map<std::string, std::set<std::string> > kcenon::common::interfaces::health_dependency_graph::dependencies_

private

Definition at line 448 of file health_dependency_graph.h.

Referenced by add_dependency(), add_node(), check_with_dependencies_internal(), clear(), get_dependencies(), remove_dependency(), remove_node(), topological_sort(), and would_create_cycle_internal().

◆ dependents_

std::unordered_map<std::string, std::set<std::string> > kcenon::common::interfaces::health_dependency_graph::dependents_

private

Definition at line 449 of file health_dependency_graph.h.

Referenced by add_dependency(), add_node(), clear(), get_dependents(), get_failure_impact(), remove_dependency(), remove_node(), and topological_sort().

◆ mutex_

std::mutex kcenon::common::interfaces::health_dependency_graph::mutex_

mutableprivate

Definition at line 450 of file health_dependency_graph.h.

Referenced by add_dependency(), add_node(), check_with_dependencies(), clear(), empty(), get_all_nodes(), get_dependencies(), get_dependents(), get_failure_impact(), has_node(), remove_dependency(), remove_node(), size(), topological_sort(), and would_create_cycle().

◆ nodes_

std::unordered_map<std::string, std::shared_ptr<health_check> > kcenon::common::interfaces::health_dependency_graph::nodes_

private

Definition at line 447 of file health_dependency_graph.h.

Referenced by add_dependency(), add_node(), check_with_dependencies(), check_with_dependencies_internal(), clear(), empty(), get_all_nodes(), has_node(), remove_dependency(), remove_node(), size(), and topological_sort().

The documentation for this class was generated from the following file:

include/kcenon/common/interfaces/monitoring/health_dependency_graph.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ health_dependency_graph() [1/3]

◆ ~health_dependency_graph()

◆ health_dependency_graph() [2/3]

◆ health_dependency_graph() [3/3]

Member Function Documentation

◆ add_dependency()

◆ add_node()

◆ check_with_dependencies()

◆ check_with_dependencies_internal()

◆ clear()

◆ empty()

◆ get_all_nodes()

◆ get_dependencies()

◆ get_dependents()

◆ get_failure_impact()

◆ has_node()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ remove_dependency()

◆ remove_node()

◆ size()

◆ topological_sort()

◆ would_create_cycle()

◆ would_create_cycle_internal()

Member Data Documentation

◆ dependencies_

◆ dependents_

◆ mutex_

◆ nodes_