api_qualification.rs (6076B)
1 use std::{collections::BTreeSet, fs, path::Path, process::Command}; 2 3 use serde::Deserialize; 4 5 #[derive(Debug, Deserialize)] 6 struct Contract { 7 schema_version: u16, 8 baseline_revision: String, 9 tool: String, 10 minimum_tool_version: String, 11 release_type: String, 12 feature_policy: String, 13 packages: Vec<String>, 14 baseline_override: Vec<BaselineOverride>, 15 } 16 17 #[derive(Debug, Deserialize)] 18 struct BaselineOverride { 19 package: String, 20 revision: String, 21 } 22 23 pub fn run(root: &Path) -> Result<(), String> { 24 let contract = load(root)?; 25 let expected = crate::catalog::public_packages(root)?; 26 validate(&contract, expected.len())?; 27 if contract.packages.iter().collect::<BTreeSet<_>>() != expected.iter().collect() { 28 return Err("public API contract must match the current public allocation".to_owned()); 29 } 30 verify_tool(&contract)?; 31 verify_revision(root, &contract.baseline_revision)?; 32 for baseline in &contract.baseline_override { 33 verify_revision(root, &baseline.revision)?; 34 } 35 for package in &contract.packages { 36 let args = invocation(&contract, package); 37 eprintln!("cargo {}", args.join(" ")); 38 let status = Command::new("cargo") 39 .args(&args) 40 .env("CARGO_PROFILE_DEV_DEBUG", "none") 41 .current_dir(root) 42 .status() 43 .map_err(|error| format!("failed to start cargo-semver-checks: {error}"))?; 44 if !status.success() { 45 return Err(format!("public API qualification failed for {package}")); 46 } 47 } 48 Ok(()) 49 } 50 51 fn load(root: &Path) -> Result<Contract, String> { 52 let path = root.join("contracts/releases/api_semver.toml"); 53 let raw = fs::read_to_string(&path) 54 .map_err(|error| format!("failed to read {}: {error}", path.display()))?; 55 toml::from_str(&raw).map_err(|error| format!("failed to parse {}: {error}", path.display())) 56 } 57 58 fn validate(contract: &Contract, expected_packages: usize) -> Result<(), String> { 59 if contract.schema_version != 1 60 || contract.tool != "cargo-semver-checks" 61 || contract.release_type != "major" 62 || contract.feature_policy != "all" 63 || contract.baseline_revision.len() < 7 64 { 65 return Err("invalid public API qualification contract".to_owned()); 66 } 67 let unique = contract.packages.iter().collect::<BTreeSet<_>>(); 68 if unique.len() != expected_packages || unique.len() != contract.packages.len() { 69 return Err(format!( 70 "public API contract requires exactly {expected_packages} unique packages" 71 )); 72 } 73 let overrides = contract 74 .baseline_override 75 .iter() 76 .map(|baseline| baseline.package.as_str()) 77 .collect::<BTreeSet<_>>(); 78 if overrides 79 != BTreeSet::from([ 80 "radroots", 81 "radroots_sdk", 82 "radroots_domain", 83 "radroots_execution", 84 "radroots_transport_nostr_native", 85 ]) 86 || contract.baseline_override.len() != overrides.len() 87 || contract 88 .baseline_override 89 .iter() 90 .any(|baseline| baseline.revision.len() != 40) 91 { 92 return Err( 93 "public API baselines must identify imported front doors and new shared owners" 94 .to_owned(), 95 ); 96 } 97 Ok(()) 98 } 99 100 fn verify_tool(contract: &Contract) -> Result<(), String> { 101 let output = Command::new("cargo") 102 .args(["semver-checks", "--version"]) 103 .output() 104 .map_err(|error| format!("failed to start cargo-semver-checks: {error}"))?; 105 if !output.status.success() { 106 return Err("cargo-semver-checks is required".to_owned()); 107 } 108 let stdout = String::from_utf8_lossy(&output.stdout); 109 let installed = stdout 110 .split_whitespace() 111 .find_map(|value| semver::Version::parse(value).ok()) 112 .ok_or_else(|| format!("could not parse cargo-semver-checks version: {stdout}"))?; 113 let minimum = semver::Version::parse(&contract.minimum_tool_version) 114 .map_err(|error| format!("invalid minimum tool version: {error}"))?; 115 if installed < minimum { 116 return Err(format!( 117 "cargo-semver-checks {} or newer is required, found {installed}", 118 contract.minimum_tool_version 119 )); 120 } 121 Ok(()) 122 } 123 124 fn verify_revision(root: &Path, revision: &str) -> Result<(), String> { 125 let status = Command::new("git") 126 .args(["cat-file", "-e", &format!("{revision}^{{commit}}")]) 127 .current_dir(root) 128 .status() 129 .map_err(|error| format!("failed to inspect API baseline revision: {error}"))?; 130 if status.success() { 131 Ok(()) 132 } else { 133 Err(format!("API baseline revision {revision} is unavailable")) 134 } 135 } 136 137 fn invocation(contract: &Contract, package: &str) -> Vec<String> { 138 let baseline = contract 139 .baseline_override 140 .iter() 141 .find(|baseline| baseline.package == package) 142 .map_or(contract.baseline_revision.as_str(), |baseline| { 143 baseline.revision.as_str() 144 }); 145 vec![ 146 "semver-checks".to_owned(), 147 "check-release".to_owned(), 148 "--package".to_owned(), 149 package.to_owned(), 150 "--baseline-rev".to_owned(), 151 baseline.to_owned(), 152 "--all-features".to_owned(), 153 "--release-type".to_owned(), 154 contract.release_type.clone(), 155 ] 156 } 157 158 #[cfg(test)] 159 mod tests { 160 use super::{invocation, load, validate}; 161 162 #[test] 163 fn current_contract_covers_all_library_packages() { 164 let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) 165 .parent() 166 .and_then(std::path::Path::parent) 167 .expect("workspace root"); 168 let contract = load(root).expect("contract"); 169 validate(&contract, 22).expect("valid contract"); 170 let invocation = invocation(&contract, "radroots_core"); 171 assert!(invocation.contains(&"--all-features".to_owned())); 172 assert!(invocation.ends_with(&["--release-type".to_owned(), "major".to_owned()])); 173 } 174 }