use std::collections::HashMap;
use std::sync::{Mutex, PoisonError};
use std::time::{Duration, Instant};
use crate::reconcile::error::{ExecError, ExecResult, Failure};
use crate::reconcile::identity::DeleteOutcome;
use crate::reconcile::status::ConditionKind;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CleanupView {
pub deployment: Option<DeploymentPhase>,
pub consumers: Vec<String>,
pub kanidm_present: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DeploymentPhase {
Live,
Deleting,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SkipReason {
KanidmGone,
AccountNotOwned,
}
impl SkipReason {
pub fn reason(self) -> &'static str {
match self {
Self::KanidmGone => "KanidmNotFound",
Self::AccountNotOwned => "AccountNotOwned",
}
}
pub fn note(self) -> &'static str {
match self {
Self::KanidmGone => {
"referenced Kanidm no longer exists; its RADIUS service account was not cleaned up"
}
Self::AccountNotOwned => {
"Kanidm account for this resource exists without its ownership marker; left untouched"
}
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CleanupStep {
DeleteDeployment,
AwaitDrain { consumers: Vec<String> },
DeleteIdentity,
Skip(SkipReason),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Finish {
RemoveFinalizer,
SkipAndRemove(SkipReason),
}
pub fn next_step(view: &CleanupView) -> CleanupStep {
match view.deployment {
Some(DeploymentPhase::Live) => CleanupStep::DeleteDeployment,
Some(DeploymentPhase::Deleting) => CleanupStep::AwaitDrain {
consumers: view.consumers.clone(),
},
None if !view.consumers.is_empty() => CleanupStep::AwaitDrain {
consumers: view.consumers.clone(),
},
None if view.kanidm_present => CleanupStep::DeleteIdentity,
None => CleanupStep::Skip(SkipReason::KanidmGone),
}
}
pub const DRAIN_WARNING_REASON: &str = "AwaitingConsumers";
pub const DRAIN_WARNING_INTERVAL: Duration = Duration::from_secs(10 * 60);
const DRAIN_NOTE_MAX_CONSUMERS: usize = 10;
pub fn drain_note(consumers: &[String]) -> String {
let mut named = consumers
.iter()
.take(DRAIN_NOTE_MAX_CONSUMERS)
.map(String::as_str)
.collect::<Vec<_>>()
.join(", ");
let rest = consumers.len().saturating_sub(DRAIN_NOTE_MAX_CONSUMERS);
if rest > 0 {
named.push_str(&format!(" and {rest} more"));
}
format!("deletion waits until these stop using the config Secrets or tokens: {named}")
}
#[derive(Debug, Default)]
pub struct DrainWarnings {
last: Mutex<HashMap<String, (Vec<String>, Instant)>>,
}
impl DrainWarnings {
pub fn should_warn(&self, uid: &str, consumers: &[String], now: Instant) -> bool {
if consumers.is_empty() {
return false;
}
let mut set = consumers.to_vec();
set.sort();
let mut last = self.last.lock().unwrap_or_else(PoisonError::into_inner);
last.retain(|_, (_, at)| now.saturating_duration_since(*at) < DRAIN_WARNING_INTERVAL);
let due = last.get(uid).is_none_or(|(previous, at)| {
*previous != set || now.saturating_duration_since(*at) >= DRAIN_WARNING_INTERVAL
});
if due {
last.insert(uid.to_string(), (set, now));
}
due
}
pub fn forget(&self, uid: &str) {
self.last
.lock()
.unwrap_or_else(PoisonError::into_inner)
.remove(uid);
}
}
pub fn identity_cleanup(result: ExecResult<DeleteOutcome>) -> Result<Finish, Failure> {
match result {
Ok(DeleteOutcome::Deleted | DeleteOutcome::AlreadyAbsent) => Ok(Finish::RemoveFinalizer),
Err(ExecError::AccountNotOwned { .. }) => {
Ok(Finish::SkipAndRemove(SkipReason::AccountNotOwned))
}
Err(error) => Err(Failure::exec(ConditionKind::IdentityReady)(error)),
}
}
#[cfg(test)]
mod tests {
use kaniop_k8s_util::error::Error;
use super::*;
fn view(deployment: Option<DeploymentPhase>, consumers: &[&str], kanidm: bool) -> CleanupView {
CleanupView {
deployment,
consumers: consumers.iter().map(|c| c.to_string()).collect(),
kanidm_present: kanidm,
}
}
#[test]
fn steps_run_in_order() {
use DeploymentPhase::*;
let cases = [
(
view(Some(Live), &["pod/a"], true),
CleanupStep::DeleteDeployment,
),
(view(Some(Live), &[], false), CleanupStep::DeleteDeployment),
(
view(Some(Deleting), &[], true),
CleanupStep::AwaitDrain { consumers: vec![] },
),
(
view(None, &["replicaset/b", "pod/a"], true),
CleanupStep::AwaitDrain {
consumers: vec!["replicaset/b".into(), "pod/a".into()],
},
),
(
view(None, &["pod/a"], false),
CleanupStep::AwaitDrain {
consumers: vec!["pod/a".into()],
},
),
(view(None, &[], true), CleanupStep::DeleteIdentity),
(
view(None, &[], false),
CleanupStep::Skip(SkipReason::KanidmGone),
),
];
for (view, expected) in cases {
assert_eq!(next_step(&view), expected, "{view:?}");
}
}
fn names(names: &[&str]) -> Vec<String> {
names.iter().map(|n| n.to_string()).collect()
}
#[test]
fn drain_warnings_only_on_change_or_after_the_interval() {
let warnings = DrainWarnings::default();
let t0 = Instant::now();
let set = names(&["pod/a", "replicaset/b"]);
assert!(!warnings.should_warn("uid-1", &[], t0), "nothing to name");
assert!(warnings.should_warn("uid-1", &set, t0), "first time");
assert!(!warnings.should_warn("uid-1", &set, t0 + Duration::from_secs(5)));
let reordered = names(&["replicaset/b", "pod/a"]);
assert!(!warnings.should_warn("uid-1", &reordered, t0 + Duration::from_secs(10)));
assert!(warnings.should_warn("uid-2", &set, t0 + Duration::from_secs(10)));
let shrunk = names(&["pod/a"]);
assert!(warnings.should_warn("uid-1", &shrunk, t0 + Duration::from_secs(15)));
assert!(!warnings.should_warn("uid-1", &shrunk, t0 + Duration::from_secs(20)));
let later = t0 + Duration::from_secs(15) + DRAIN_WARNING_INTERVAL;
assert!(warnings.should_warn("uid-1", &shrunk, later));
assert!(!warnings.should_warn("uid-1", &shrunk, later + Duration::from_secs(5)));
warnings.forget("uid-1");
assert!(warnings.should_warn("uid-1", &shrunk, later + Duration::from_secs(10)));
}
#[test]
fn drain_note_names_consumers_and_is_bounded() {
let note = drain_note(&names(&["pod/a", "replicaset/b"]));
assert!(note.contains("pod/a, replicaset/b"), "{note}");
let many: Vec<String> = (0..25).map(|i| format!("pod/p{i}")).collect();
let note = drain_note(&many);
assert!(note.contains("pod/p9"), "{note}");
assert!(!note.contains("pod/p10"), "{note}");
assert!(note.contains("and 15 more"), "{note}");
}
#[test]
fn identity_cleanup_outcomes() {
assert_eq!(
identity_cleanup(Ok(DeleteOutcome::Deleted)).unwrap(),
Finish::RemoveFinalizer
);
assert_eq!(
identity_cleanup(Ok(DeleteOutcome::AlreadyAbsent)).unwrap(),
Finish::RemoveFinalizer
);
assert_eq!(
identity_cleanup(Err(ExecError::AccountNotOwned {
account: "kaniop_radius_x".into()
}))
.unwrap(),
Finish::SkipAndRemove(SkipReason::AccountNotOwned)
);
match identity_cleanup(Err(ExecError::Api(Error::MissingData("down".into())))) {
Err(Failure::Transient { condition, error }) => {
assert_eq!(condition, ConditionKind::IdentityReady);
assert_eq!(error.to_string(), "down");
}
other => panic!("expected transient, got {other:?}"),
}
}
}