#[derive(Debug, Clone, Copy)]
enum CoverageCut {
Count(usize),
Percent(u64),
}
const LADDER: &[CoverageCut] = &[
CoverageCut::Count(1), CoverageCut::Percent(10),
CoverageCut::Percent(30),
CoverageCut::Percent(70),
];
pub const PHASE_COUNTS: &[usize] = &[2, 3, 4, 5];
pub fn available_phase_counts(total: usize) -> Vec<usize> {
if total == 0 {
return Vec::new();
}
let feasible: Vec<usize> = PHASE_COUNTS
.iter()
.copied()
.filter(|count| *count <= total)
.collect();
if feasible.is_empty() {
vec![1]
} else {
feasible
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Phase {
pub index: usize,
pub target_ids: Vec<String>,
pub coverage_percent: Option<u64>,
pub is_canary: bool,
pub is_final: bool,
}
pub fn plan_phases(targets: &[String], phase_count: usize) -> Result<Vec<Phase>, String> {
let total = targets.len();
let mut order: Vec<String> = targets.to_vec();
order.sort();
if total == 0 {
return Err("还没选任何目标,无法分配阶段。".to_string());
}
if phase_count == 0 {
return Err("阶段数至少为 1。".to_string());
}
if phase_count > total {
return Err(format!(
"只选了 {total} 个目标,分不出 {phase_count} 个非空阶段。"
));
}
let mut cuts: Vec<usize> = Vec::with_capacity(phase_count);
let mut previous = 0usize;
for i in 0..phase_count.saturating_sub(1) {
let cut = LADDER[i.min(LADDER.len() - 1)];
let upper = total - (phase_count - i - 1);
let size = (previous + 1).max(cut_size(cut, total).min(upper));
cuts.push(size);
previous = size;
}
cuts.push(total);
let mut phases = Vec::with_capacity(cuts.len());
let mut start = 0usize;
for (i, end) in cuts.iter().copied().enumerate() {
let target_ids = order[start..end].to_vec();
phases.push(Phase {
index: i + 1,
coverage_percent: if end == total {
Some(100)
} else {
ladder_coverage_percent(i)
},
is_canary: i == 0 && target_ids.len() == 1 && end != total,
is_final: end == total,
target_ids,
});
start = end;
}
Ok(phases)
}
pub fn phase_scale_label(phase: &Phase) -> String {
if phase.is_canary {
return "1 个(金丝雀)".to_string();
}
format!("覆盖 ~{}%", phase.coverage_percent.unwrap_or(0))
}
fn ladder_coverage_percent(i: usize) -> Option<u64> {
match LADDER[i.min(LADDER.len() - 1)] {
CoverageCut::Percent(value) => Some(value),
CoverageCut::Count(_) => None,
}
}
fn cut_size(cut: CoverageCut, total: usize) -> usize {
match cut {
CoverageCut::Count(value) => value.min(total),
CoverageCut::Percent(percent) => ((percent as usize) * total).div_ceil(100).min(total),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn targets(n: usize) -> Vec<String> {
(1..=n).map(|i| format!("gw-{i:03}")).collect()
}
fn sizes(phases: &[Phase]) -> Vec<usize> {
phases.iter().map(|p| p.target_ids.len()).collect()
}
#[test]
fn available_counts_shrink_with_the_target_size() {
assert_eq!(available_phase_counts(10), vec![2, 3, 4, 5]);
assert_eq!(available_phase_counts(3), vec![2, 3]);
assert_eq!(available_phase_counts(1), vec![1]);
assert!(available_phase_counts(0).is_empty());
}
#[test]
fn cuts_follow_the_ladder_and_cover_everything_once() {
assert_eq!(sizes(&plan_phases(&targets(10), 2).unwrap()), vec![1, 9]);
assert_eq!(sizes(&plan_phases(&targets(10), 3).unwrap()), vec![1, 1, 8]);
assert_eq!(
sizes(&plan_phases(&targets(10), 4).unwrap()),
vec![1, 1, 1, 7]
);
assert_eq!(
sizes(&plan_phases(&targets(10), 5).unwrap()),
vec![1, 1, 1, 4, 3]
);
}
#[test]
fn phases_are_disjoint_and_ordered() {
let phases = plan_phases(&targets(10), 5).unwrap();
let mut all: Vec<String> = phases.iter().flat_map(|p| p.target_ids.clone()).collect();
assert_eq!(all.len(), 10);
all.sort();
all.dedup();
assert_eq!(all.len(), 10, "阶段之间互不重叠");
assert_eq!(phases[0].target_ids, vec!["gw-001"]);
assert!(phases[0].is_canary && !phases[0].is_final);
assert!(phases.last().unwrap().is_final);
assert_eq!(phases[2].coverage_percent, Some(30));
}
#[test]
fn small_fleets_stay_non_empty_and_single_target_is_not_a_canary() {
assert_eq!(
sizes(&plan_phases(&targets(5), 5).unwrap()),
vec![1, 1, 1, 1, 1]
);
assert_eq!(sizes(&plan_phases(&targets(3), 3).unwrap()), vec![1, 1, 1]);
let one = plan_phases(&targets(1), 1).unwrap();
assert_eq!(sizes(&one), vec![1]);
assert!(!one[0].is_canary && one[0].is_final);
}
#[test]
fn refuses_empty_and_infeasible_counts() {
assert!(plan_phases(&[], 2).is_err());
assert!(plan_phases(&targets(2), 5).is_err());
}
#[test]
fn refuses_a_zero_phase_count() {
assert!(plan_phases(&targets(5), 0).is_err());
assert!(plan_phases(&[], 0).is_err());
assert_eq!(sizes(&plan_phases(&targets(5), 1).unwrap()), vec![5]);
}
#[test]
fn large_fleets_follow_the_ladder_percentages() {
assert_eq!(
sizes(&plan_phases(&targets(100), 5).unwrap()),
vec![1, 9, 20, 40, 30]
);
assert_eq!(sizes(&plan_phases(&targets(100), 2).unwrap()), vec![1, 99]);
assert_eq!(
sizes(&plan_phases(&targets(100), 3).unwrap()),
vec![1, 9, 90]
);
}
#[test]
fn every_preset_yields_disjoint_phases_that_cover_the_fleet_once() {
for total in 1..=24usize {
let fleet = targets(total);
for count in available_phase_counts(total) {
let phases = plan_phases(&fleet, count).unwrap();
assert_eq!(phases.len(), count, "total {total} count {count}");
assert!(phases.iter().all(|phase| !phase.target_ids.is_empty()));
assert!(phases.iter().enumerate().all(|(i, p)| p.index == i + 1));
assert_eq!(phases.iter().filter(|p| p.is_final).count(), 1);
assert_eq!(
phases.iter().filter(|p| p.is_canary).count(),
usize::from(total > 1),
"total {total} count {count}"
);
let mut all: Vec<String> =
phases.iter().flat_map(|p| p.target_ids.clone()).collect();
assert_eq!(all.len(), total, "total {total} count {count}");
all.sort();
all.dedup();
assert_eq!(all.len(), total, "total {total} count {count}");
}
}
}
#[test]
fn small_fleets_keep_the_ladder_labels_even_when_clamped() {
assert_eq!(available_phase_counts(4), vec![2, 3, 4]);
let phases = plan_phases(&targets(4), 4).unwrap();
assert_eq!(sizes(&phases), vec![1, 1, 1, 1]);
assert_eq!(phase_scale_label(&phases[1]), "覆盖 ~10%");
assert_eq!(phases[3].coverage_percent, Some(100));
}
#[test]
fn scale_labels_read_the_ladder_level() {
let phases = plan_phases(&targets(10), 4).unwrap();
assert_eq!(phase_scale_label(&phases[0]), "1 个(金丝雀)");
assert_eq!(phase_scale_label(&phases[1]), "覆盖 ~10%");
assert_eq!(phase_scale_label(&phases[3]), "覆盖 ~100%");
}
}