release_qualification.rs (7113B)
1 use std::{ffi::OsString, fs, path::Path, process::Command}; 2 3 use serde::Deserialize; 4 5 #[derive(Debug, Deserialize)] 6 struct Catalog { 7 package: Vec<Package>, 8 } 9 10 #[derive(Debug, Deserialize)] 11 struct Package { 12 name: String, 13 state: String, 14 groups: Vec<String>, 15 } 16 17 #[derive(Debug, PartialEq, Eq)] 18 struct CargoInvocation { 19 args: Vec<String>, 20 } 21 22 pub fn run_feature_matrix(workspace_root: &Path) -> Result<(), String> { 23 for invocation in feature_matrix(workspace_root)? { 24 eprintln!("cargo {}", invocation.args.join(" ")); 25 let mut command = Command::new("cargo"); 26 command 27 .args(&invocation.args) 28 .current_dir(workspace_root) 29 .env("RUSTFLAGS", rustflags_with_warnings_denied()); 30 let status = command 31 .status() 32 .map_err(|error| format!("failed to start cargo: {error}"))?; 33 if !status.success() { 34 return Err(format!( 35 "public feature qualification failed: cargo {}", 36 invocation.args.join(" ") 37 )); 38 } 39 } 40 Ok(()) 41 } 42 43 fn rustflags_with_warnings_denied() -> OsString { 44 let mut rustflags = std::env::var_os("RUSTFLAGS").unwrap_or_default(); 45 if !rustflags.is_empty() { 46 rustflags.push(" "); 47 } 48 rustflags.push("-Dwarnings"); 49 rustflags 50 } 51 52 fn feature_matrix(workspace_root: &Path) -> Result<Vec<CargoInvocation>, String> { 53 let path = workspace_root.join("contracts/crates/catalog.v2.toml"); 54 let raw = fs::read_to_string(&path) 55 .map_err(|error| format!("failed to read {}: {error}", path.display()))?; 56 let catalog = toml::from_str::<Catalog>(&raw) 57 .map_err(|error| format!("failed to parse {}: {error}", path.display()))?; 58 let mut packages = catalog 59 .package 60 .into_iter() 61 .filter(|package| { 62 package.state == "active" && package.groups.iter().any(|group| group == "public_native") 63 }) 64 .collect::<Vec<_>>(); 65 packages.sort_by(|left, right| left.name.cmp(&right.name)); 66 let expected = crate::catalog::public_packages(workspace_root)?; 67 if packages 68 .iter() 69 .map(|p| p.name.as_str()) 70 .collect::<std::collections::BTreeSet<_>>() 71 != expected.iter().map(String::as_str).collect() 72 { 73 return Err(format!( 74 "library feature qualification must match current public allocation, found {} packages", 75 packages.len() 76 )); 77 } 78 79 let mut invocations = Vec::new(); 80 let feature_map = package_feature_map(workspace_root)?; 81 for package in packages { 82 let features = feature_map 83 .get(&package.name) 84 .ok_or_else(|| format!("cargo metadata omitted features for {}", package.name))?; 85 invocations.push(check_invocation(&package.name, None, true)); 86 invocations.push(check_invocation(&package.name, None, false)); 87 for feature in features { 88 invocations.push(check_invocation(&package.name, Some(feature), true)); 89 } 90 invocations.push(CargoInvocation { 91 args: vec![ 92 "check".to_owned(), 93 "-p".to_owned(), 94 package.name, 95 "--all-targets".to_owned(), 96 "--all-features".to_owned(), 97 "--locked".to_owned(), 98 ], 99 }); 100 } 101 Ok(invocations) 102 } 103 104 fn package_feature_map( 105 workspace_root: &Path, 106 ) -> Result<std::collections::BTreeMap<String, Vec<String>>, String> { 107 let output = Command::new("cargo") 108 .args(["metadata", "--format-version", "1", "--locked", "--no-deps"]) 109 .current_dir(workspace_root) 110 .output() 111 .map_err(|error| format!("failed to start cargo metadata: {error}"))?; 112 if !output.status.success() { 113 return Err("locked cargo metadata failed".to_owned()); 114 } 115 let metadata: serde_json::Value = serde_json::from_slice(&output.stdout) 116 .map_err(|error| format!("failed to parse cargo metadata: {error}"))?; 117 let packages = metadata 118 .get("packages") 119 .and_then(serde_json::Value::as_array) 120 .ok_or_else(|| "cargo metadata omitted packages".to_owned())?; 121 packages 122 .iter() 123 .map(|package| { 124 let name = package 125 .get("name") 126 .and_then(serde_json::Value::as_str) 127 .ok_or_else(|| "cargo metadata package omitted name".to_owned())?; 128 let mut features = package 129 .get("features") 130 .and_then(serde_json::Value::as_object) 131 .ok_or_else(|| format!("cargo metadata omitted features for {name}"))? 132 .keys() 133 .filter(|feature| feature.as_str() != "default") 134 .cloned() 135 .collect::<Vec<_>>(); 136 features.sort_unstable(); 137 Ok((name.to_owned(), features)) 138 }) 139 .collect() 140 } 141 142 fn check_invocation( 143 package: &str, 144 feature: Option<&str>, 145 no_default_features: bool, 146 ) -> CargoInvocation { 147 let mut args = vec!["check".to_owned(), "-p".to_owned(), package.to_owned()]; 148 if no_default_features { 149 args.push("--lib".to_owned()); 150 args.push("--no-default-features".to_owned()); 151 } else { 152 args.push("--all-targets".to_owned()); 153 } 154 if let Some(feature) = feature { 155 args.push("--features".to_owned()); 156 args.push(feature.to_owned()); 157 } 158 args.push("--locked".to_owned()); 159 CargoInvocation { args } 160 } 161 162 #[cfg(test)] 163 mod tests { 164 use super::{check_invocation, feature_matrix}; 165 166 #[test] 167 fn current_catalog_generates_the_complete_library_feature_matrix() { 168 let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) 169 .parent() 170 .and_then(std::path::Path::parent) 171 .expect("workspace root"); 172 let matrix = feature_matrix(root).expect("feature matrix"); 173 assert!(matrix.len() > 68); 174 assert!(matrix.iter().any(|entry| { 175 entry 176 .args 177 .windows(2) 178 .any(|pair| pair == ["--features", "blossom"]) 179 && entry 180 .args 181 .windows(2) 182 .any(|pair| pair == ["-p", "radroots_nostr"]) 183 })); 184 assert!(matrix.iter().any(|entry| { 185 entry 186 .args 187 .windows(2) 188 .any(|pair| pair == ["-p", "radroots_geonames"]) 189 && entry.args.iter().any(|arg| arg == "--all-features") 190 })); 191 } 192 193 #[test] 194 fn individual_features_never_enable_defaults_implicitly() { 195 let invocation = check_invocation("radroots_event", Some("knowledge"), true); 196 assert!( 197 invocation 198 .args 199 .iter() 200 .any(|arg| arg == "--no-default-features") 201 ); 202 assert_eq!( 203 invocation 204 .args 205 .windows(2) 206 .find(|pair| pair[0] == "--features"), 207 Some(&["--features".to_owned(), "knowledge".to_owned()][..]) 208 ); 209 } 210 }