lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }