#[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),
}
}
pub const ADVANCE_RULE_MANUAL: &str = "manual";
pub const ADVANCE_RULE_ALL_SUCCEEDED: &str = "all_succeeded";
pub const ADVANCE_RULE_SUCCESS_RATE_PREFIX: &str = "success_rate:";
pub fn validate_advance_rule(rule: &str) -> Result<(), String> {
let rule = rule.trim();
if rule == ADVANCE_RULE_MANUAL || rule == ADVANCE_RULE_ALL_SUCCEEDED {
return Ok(());
}
if let Some(rate) = rule.strip_prefix(ADVANCE_RULE_SUCCESS_RATE_PREFIX)
&& let Ok(value) = rate.trim().parse::<u32>()
&& value <= 100
{
return Ok(());
}
Err(format!(
"advance_rule {rule:?} must be \"manual\", \"all_succeeded\", or \"success_rate:<0..=100>\""
))
}
pub fn entry_status_for(work_status: &str) -> &'static str {
match work_status {
"succeeded" | "done" => "succeeded",
"failed" | "rolled_back" | "unverified" => "failed",
_ => "dispatched",
}
}
pub type TargetStatus<'a> = (&'a str, &'a str);
pub fn phase_settled(statuses: &[&str]) -> bool {
!statuses.is_empty()
&& statuses
.iter()
.all(|status| matches!(*status, "succeeded" | "failed"))
}
pub fn phase_should_advance(rule: &str, statuses: &[&str]) -> bool {
if !phase_settled(statuses) {
return false;
}
let total = statuses.len() as u64;
let succeeded = statuses
.iter()
.filter(|status| **status == "succeeded")
.count() as u64;
match rule.trim() {
ADVANCE_RULE_MANUAL => false,
ADVANCE_RULE_ALL_SUCCEEDED => succeeded == total,
_ => {
if let Some(rate) = rule.trim().strip_prefix(ADVANCE_RULE_SUCCESS_RATE_PREFIX)
&& let Ok(threshold) = rate.trim().parse::<u64>()
{
return succeeded * 100 >= threshold * total;
}
false
}
}
}
pub fn phase_start_targets(target_ids: &[String], batch_size: i64) -> Vec<String> {
if batch_size <= 0 {
return target_ids.to_vec();
}
let take = (batch_size as usize).min(target_ids.len());
target_ids[..take].to_vec()
}
pub fn next_refill_targets(
target_ids: &[String],
states: &[TargetStatus<'_>],
batch_size: i64,
) -> Vec<String> {
if batch_size <= 0 {
return Vec::new();
}
let status_of = |target: &str| -> Option<&str> {
states
.iter()
.find(|(id, _)| *id == target)
.map(|(_, status)| *status)
};
let in_flight = target_ids
.iter()
.filter(|target| status_of(target) == Some("dispatched"))
.count();
let needed = (batch_size as usize).saturating_sub(in_flight);
if needed == 0 {
return Vec::new();
}
target_ids
.iter()
.filter(|target| status_of(target) == Some("pending"))
.take(needed)
.cloned()
.collect()
}
pub fn target_work_id(plan_id: &str, target_id: &str) -> String {
let digest = crate::package::sha256_hex_bytes(format!("{plan_id}|{target_id}").as_bytes());
format!("work-{plan_id}-{}", &digest[..12])
}
#[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%");
}
#[test]
fn advance_rules_accept_the_documented_values_and_reject_garbage() {
for ok in [
"manual",
"all_succeeded",
"success_rate:0",
"success_rate:80",
"success_rate:100",
] {
assert!(validate_advance_rule(ok).is_ok(), "{ok}");
}
for bad in [
"",
"auto",
"success_rate:101",
"success_rate:abc",
"rate:50",
] {
assert!(validate_advance_rule(bad).is_err(), "{bad}");
}
}
#[test]
fn entry_status_folds_in_flight_and_terminal_onto_the_closed_set() {
assert_eq!(entry_status_for("succeeded"), "succeeded");
assert_eq!(entry_status_for("done"), "succeeded");
for failed in ["failed", "rolled_back", "unverified"] {
assert_eq!(entry_status_for(failed), "failed", "{failed}");
}
for flying in ["running", "dispatched", "accepted"] {
assert_eq!(entry_status_for(flying), "dispatched", "{flying}");
}
}
#[test]
fn a_phase_advances_only_when_settled_and_the_rule_holds() {
let in_flight = ["succeeded", "dispatched"];
assert!(!phase_should_advance("all_succeeded", &in_flight));
assert!(!phase_should_advance("success_rate:50", &in_flight));
let all_ok = ["succeeded", "succeeded"];
assert!(phase_should_advance("all_succeeded", &all_ok));
assert!(phase_should_advance("success_rate:100", &all_ok));
let one_failed = ["succeeded", "failed"];
assert!(!phase_should_advance("all_succeeded", &one_failed));
assert!(phase_should_advance("success_rate:50", &one_failed));
assert!(!phase_should_advance("success_rate:51", &one_failed));
assert!(!phase_should_advance("manual", &all_ok));
assert!(!phase_should_advance("all_succeeded", &[]));
}
#[test]
fn start_and_refill_keep_the_batch_in_flight() {
let fleet = ["a", "b", "c", "d"].map(str::to_string).to_vec();
assert_eq!(phase_start_targets(&fleet, 0), vec!["a", "b", "c", "d"]);
assert_eq!(phase_start_targets(&fleet, 2), vec!["a", "b"]);
assert_eq!(phase_start_targets(&fleet, 10), vec!["a", "b", "c", "d"]);
let states = [
("a", "dispatched"),
("b", "pending"),
("c", "pending"),
("d", "pending"),
];
assert_eq!(next_refill_targets(&fleet, &states, 2), vec!["b"]);
let states = [
("a", "succeeded"),
("b", "failed"),
("c", "pending"),
("d", "pending"),
];
assert_eq!(next_refill_targets(&fleet, &states, 2), vec!["c", "d"]);
assert!(next_refill_targets(&fleet, &states, 0).is_empty());
}
#[test]
fn work_id_is_deterministic_per_target() {
let id = target_work_id("plan-1", "gw-001");
assert_eq!(id, target_work_id("plan-1", "gw-001"));
assert_ne!(id, target_work_id("plan-1", "gw-002"));
assert_ne!(id, target_work_id("plan-2", "gw-001"));
assert!(id.starts_with("work-plan-1-"));
assert_eq!(id.len(), "work-plan-1-".len() + 12);
}
}