hyprstream_service/service/
ordering.rs1use std::collections::{HashMap, HashSet};
9
10use crate::service::factory::list_factories;
11
12pub fn startup_stages(requested: &[impl AsRef<str>]) -> Vec<Vec<String>> {
26 startup_stages_for_profile(requested, false)
27}
28
29pub fn startup_stages_for_profile(
32 requested: &[impl AsRef<str>],
33 iroh_required: bool,
34) -> Vec<Vec<String>> {
35 let requested_set: HashSet<&str> = requested.iter().map(AsRef::as_ref).collect();
36
37 let mut deps: HashMap<&str, Vec<&str>> = HashMap::new();
39 for factory in list_factories() {
40 if !requested_set.contains(factory.name) {
41 continue;
42 }
43 let service_deps: Vec<&str> = factory
44 .depends_on
45 .iter()
46 .copied()
47 .filter(|d| requested_set.contains(d))
48 .collect();
49 deps.insert(factory.name, service_deps);
50 }
51
52 for &name in &requested_set {
54 deps.entry(name).or_default();
55 }
56 if iroh_required {
57 if let Some(discovery) = deps.get_mut("discovery") {
58 discovery.retain(|dependency| *dependency != "policy");
59 }
60 if requested_set.contains("discovery") {
61 if let Some(policy) = deps.get_mut("policy") {
62 policy.push("discovery");
63 }
64 }
65 }
66
67 let mut in_degree: HashMap<&str, usize> = HashMap::new();
69 for (&svc, svc_deps) in &deps {
70 in_degree.entry(svc).or_insert(0);
71 for &dep in svc_deps {
72 *in_degree.entry(svc).or_insert(0) += 1;
74 in_degree.entry(dep).or_insert(0);
75 }
76 }
77
78 let mut dependents: HashMap<&str, Vec<&str>> = HashMap::new();
80 for (&svc, svc_deps) in &deps {
81 for &dep in svc_deps {
82 dependents.entry(dep).or_default().push(svc);
83 }
84 }
85
86 let mut stages: Vec<Vec<String>> = Vec::new();
87 let mut remaining: HashSet<&str> = deps.keys().copied().collect();
88
89 while !remaining.is_empty() {
90 let mut stage: Vec<&str> = remaining
92 .iter()
93 .filter(|&&s| in_degree.get(s).copied().unwrap_or(0) == 0)
94 .copied()
95 .collect();
96
97 assert!(
98 !stage.is_empty(),
99 "dependency cycle detected among: {:?}",
100 remaining
101 );
102
103 stage.sort(); for &svc in &stage {
107 remaining.remove(svc);
108 if let Some(deps_of_svc) = dependents.get(svc) {
109 for &dependent in deps_of_svc {
110 if let Some(deg) = in_degree.get_mut(dependent) {
111 *deg = deg.saturating_sub(1);
112 }
113 }
114 }
115 }
116
117 stages.push(stage.into_iter().map(String::from).collect());
118 }
119
120 stages
121}
122
123#[cfg(test)]
124mod tests {
125 use super::*;
126
127 #[test]
131 fn test_empty_requested() {
132 let stages = startup_stages(&Vec::<String>::new());
133 assert!(stages.is_empty());
134 }
135
136 #[test]
137 fn test_stages_from_inventory() {
138 let stages = startup_stages(&["policy", "registry", "model"]);
142 let all: Vec<&str> = stages
144 .iter()
145 .flat_map(|s| s.iter().map(String::as_str))
146 .collect();
147 assert!(all.len() <= 3);
149 }
150}