use std::collections::BTreeSet;
use std::path::Path;
use shep_core::config::graph::BootPlan;
use shep_core::config::{DeclaredApp, ResolvedApp};
use shep_core::protocol::{RpcError, RpcErrorCode, SheepApplied};
use crate::supervisor::Applied;
use super::context::RpcContext;
pub(super) fn persists(dogs_config: &Path, namespace: &str) -> bool {
let Ok(source) = std::fs::read_to_string(dogs_config) else {
return true;
};
let Ok(config) = shep_core::config::DogsConfig::load(Some(&source)) else {
return true;
};
config
.dog
.get(namespace)
.and_then(|table| table.get("persist"))
.and_then(toml::Value::as_bool)
.unwrap_or(true)
}
pub(super) fn staged_plan(ctx: &RpcContext, apps: &[ResolvedApp]) -> Result<BootPlan, RpcError> {
let mut edges = ctx.registry.depends_on_by_name();
for dog in &ctx.dog_names {
edges.entry(dog.clone()).or_default();
}
for app in apps {
edges.insert(app.config().name.clone(), app.config().depends_on.clone());
}
let plan = crate::boot_order::plan_for_names(&edges);
let batch: BTreeSet<&str> = apps.iter().map(|app| app.config().name.as_str()).collect();
let cycle = plan
.knots
.iter()
.position(|knot| knot.iter().any(|name| batch.contains(name.as_str())))
.and_then(|knot| plan.cycles.get(knot));
if let Some(cycle) = cycle {
return Err(RpcError {
code: RpcErrorCode::InvalidConfig,
message: format!(
"dependency cycle: {}",
shep_core::config::graph::render_cycle(cycle)
),
daemon_version: None,
});
}
for unresolved in &plan.unresolved {
if batch.contains(unresolved.dependent.as_str()) {
tracing::warn!(
sheep = %unresolved.dependent,
missing = %unresolved.missing,
"a dependency names nothing this flock has; starting without it"
);
}
}
Ok(BootPlan {
stages: plan
.stages
.iter()
.map(|stage| {
stage
.iter()
.filter(|name| batch.contains(name.as_str()))
.cloned()
.collect::<Vec<String>>()
})
.filter(|stage| !stage.is_empty())
.collect(),
unresolved: plan.unresolved,
cycles: Vec::new(),
knots: Vec::new(),
})
}
pub(super) fn duplicate_name(apps: &[DeclaredApp]) -> Option<String> {
let mut seen = BTreeSet::new();
apps.iter()
.find(|app| !seen.insert(app.config.name.as_str()))
.map(|app| app.config.name.clone())
}
impl From<Applied> for SheepApplied {
fn from(applied: Applied) -> Self {
Self::new(
applied.name,
applied.applied,
applied.pending,
applied.refused,
)
}
}