appcore-supervisor 1.0.1

Dependency-aware managed-service supervision with bounded restart policy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

// =============================================================================
//        #######
//     ###       ###     F: graph.rs
//    ##   ## ##   ##    P: AppCore-Runtime
//         ## ##
//                       C: 2026/07/24 13:18:47 by dnettoRaw
//    ##   ## ##   ##    U: 2026/07/24 13:18:47 by dnettoRaw
//      ###########      S: 1.0.1-rc.8
// =============================================================================

//! Managed-service dependency graph validation and ordering.

use crate::{DependencyRequirement, ManagedService, SupervisorError, SupervisorResult};
use std::collections::{BTreeMap, BTreeSet};
use std::sync::Arc;

pub(crate) fn validate_dependencies(
    services: &BTreeMap<String, Arc<dyn ManagedService>>,
) -> SupervisorResult<()> {
    for (name, service) in services {
        for dependency in service.descriptor().dependencies() {
            if !services.contains_key(dependency.service_id())
                && dependency.requirement() != DependencyRequirement::Optional
            {
                return Err(SupervisorError::DependencyNotFound {
                    service: name.clone(),
                    dependency: dependency.service_id().to_string(),
                });
            }
        }
    }
    Ok(())
}

pub(crate) fn topological_order(
    services: &BTreeMap<String, Arc<dyn ManagedService>>,
) -> SupervisorResult<Vec<String>> {
    let mut temporary = BTreeSet::new();
    let mut permanent = BTreeSet::new();
    let mut order = Vec::with_capacity(services.len());
    for name in services.keys() {
        visit(
            name,
            services,
            &mut temporary,
            &mut permanent,
            &mut order,
            &mut Vec::new(),
        )?;
    }
    Ok(order)
}

fn visit(
    name: &str,
    services: &BTreeMap<String, Arc<dyn ManagedService>>,
    temporary: &mut BTreeSet<String>,
    permanent: &mut BTreeSet<String>,
    order: &mut Vec<String>,
    path: &mut Vec<String>,
) -> SupervisorResult<()> {
    if permanent.contains(name) {
        return Ok(());
    }
    if !temporary.insert(name.to_string()) {
        path.push(name.to_string());
        return Err(SupervisorError::DependencyCycle(path.clone()));
    }
    path.push(name.to_string());
    let service = services
        .get(name)
        .ok_or_else(|| SupervisorError::ServiceNotFound(name.to_string()))?;
    for dependency in service.descriptor().dependencies() {
        if services.contains_key(dependency.service_id()) {
            visit(
                dependency.service_id(),
                services,
                temporary,
                permanent,
                order,
                path,
            )?;
        }
    }
    path.pop();
    temporary.remove(name);
    permanent.insert(name.to_string());
    order.push(name.to_string());
    Ok(())
}