use std::collections::BTreeSet;
use std::hash::{BuildHasher, Hash, Hasher, RandomState};
use std::sync::OnceLock;
use shep_core::protocol::{EnvCopyChange, EnvCopyKind};
use shep_core::secrets::shown_env_value;
use super::actor_pane::record_env_edit;
use super::*;
impl<R: ProcessRunner> Actor<R> {
pub(super) fn handle_copy_sheep_env(
&mut self,
from: &str,
to: &str,
replace: bool,
except: &[String],
dry_run: bool,
expect: Option<&[EnvCopyChange]>,
) -> Result<EnvCopy, SupervisorError> {
let source_id = self
.representative_id(from)
.ok_or_else(|| SupervisorError::NoSuchSheep(from.to_string()))?;
let target_id = self
.representative_id(to)
.ok_or_else(|| SupervisorError::NoSuchSheep(to.to_string()))?;
self.ensure_not_dog(from, source_id)?;
self.ensure_not_dog(to, target_id)?;
let source = self
.intended_spec(source_id)
.map(|spec| spec.config().env.clone())
.ok_or_else(|| SupervisorError::NoSuchSheep(from.to_string()))?;
let mut intended = self
.intended_spec(target_id)
.map(|spec| spec.config().clone())
.ok_or_else(|| SupervisorError::NoSuchSheep(to.to_string()))?;
let except: BTreeSet<&str> = except.iter().map(String::as_str).collect();
let before = intended.env.clone();
let mut after = before.clone();
for (key, value) in &source {
if !except.contains(key.as_str()) {
after.insert(key.clone(), value.clone());
}
}
if replace {
after.retain(|key, _| except.contains(key.as_str()) || source.contains_key(key));
}
let changes = diff(&before, &after);
if let Some(reviewed) = expect
&& reviewed != changes
{
return Err(SupervisorError::EnvChanged(differing_keys(
reviewed, &changes,
)));
}
if changes.is_empty() {
return Ok(EnvCopy { app: None, changes });
}
intended.env = after.clone();
let parked =
normalize(intended).map_err(|err| SupervisorError::InvalidEnv(err.to_string()))?;
if dry_run {
return Ok(EnvCopy { app: None, changes });
}
let overridden = self.mutate_override(to, |record| {
for change in &changes {
let value = after.get(&change.key).map(String::as_str);
record_env_edit(
record,
to,
&change.key,
value,
before.contains_key(&change.key),
)?;
}
Ok(())
})?;
self.park_slots(to, &parked, &overridden);
Ok(EnvCopy {
app: Some(parked),
changes,
})
}
}
fn seal(old: Option<&String>, new: Option<&String>) -> u64 {
static KEY: OnceLock<RandomState> = OnceLock::new();
let mut hasher = KEY.get_or_init(RandomState::new).build_hasher();
old.hash(&mut hasher);
new.hash(&mut hasher);
hasher.finish()
}
fn differing_keys(reviewed: &[EnvCopyChange], now: &[EnvCopyChange]) -> String {
let keys: BTreeSet<&str> = reviewed
.iter()
.filter(|change| !now.contains(change))
.chain(now.iter().filter(|change| !reviewed.contains(change)))
.map(|change| change.key.as_str())
.collect();
keys.into_iter().collect::<Vec<_>>().join(", ")
}
fn diff(before: &BTreeMap<String, String>, after: &BTreeMap<String, String>) -> Vec<EnvCopyChange> {
let keys: BTreeSet<&String> = before.keys().chain(after.keys()).collect();
keys.into_iter()
.filter_map(|key| {
let (old, new) = (before.get(key), after.get(key));
let kind = match (old, new) {
(Some(old), Some(new)) if old == new => return None,
(Some(_), Some(_)) => EnvCopyKind::Changed,
(None, Some(_)) => EnvCopyKind::Added,
(Some(_), None) => EnvCopyKind::Removed,
(None, None) => return None,
};
Some(
EnvCopyChange::new(
key.as_str(),
kind,
old.map(|value| shown_env_value(value)),
new.map(|value| shown_env_value(value)),
)
.sealed(seal(old, new)),
)
})
.collect()
}