bindings.rs (15774B)
1 use std::{ 2 collections::{BTreeMap, BTreeSet}, 3 env, fs, 4 path::{Path, PathBuf}, 5 process::Command, 6 }; 7 8 use serde::{Deserialize, Serialize}; 9 use sha2::{Digest, Sha256}; 10 11 use crate::{build_control::Mode, sdk_generation::fs::write_or_check}; 12 13 const FFI_PACKAGE: &str = "radroots_sdk_ffi"; 14 const FFI_VERSION: &str = "0.1.0-alpha"; 15 const BINDGEN_VERSION: &str = "0.32.2+radroots-native-v2"; 16 const BINDGEN: &str = "radroots_ffi_bindgen"; 17 18 #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)] 19 struct SourceLock { 20 schema_version: u16, 21 source_package: String, 22 source_version: String, 23 source_sha256: String, 24 generator: String, 25 generator_version: String, 26 language: String, 27 outputs: BTreeMap<String, String>, 28 } 29 30 pub fn generate( 31 source_root: &Path, 32 consumer_root: &Path, 33 language: &str, 34 mode: Mode, 35 ) -> Result<(), String> { 36 if !matches!(language, "swift" | "kotlin") { 37 return Err("SDK binding language must be swift or kotlin".to_owned()); 38 } 39 build_bindgen(source_root)?; 40 let target_dir = env::var_os("CARGO_TARGET_DIR") 41 .map(PathBuf::from) 42 .ok_or_else(|| "CARGO_TARGET_DIR must be set by extbuild for FFI generation".to_owned())?; 43 let library = target_dir.join("debug").join(format!( 44 "{}radroots_sdk_ffi{}", 45 env::consts::DLL_PREFIX, 46 env::consts::DLL_SUFFIX 47 )); 48 if !library.is_file() { 49 return Err(format!("missing built FFI library: {}", library.display())); 50 } 51 let bindgen = target_dir 52 .join("debug") 53 .join(format!("{BINDGEN}{}", env::consts::EXE_SUFFIX)); 54 if !bindgen.is_file() { 55 return Err(format!( 56 "missing FFI bindgen executable: {}", 57 bindgen.display() 58 )); 59 } 60 let temporary = tempfile::tempdir() 61 .map_err(|error| format!("failed to create binding output directory: {error}"))?; 62 let generated = temporary.path().join("bindings"); 63 let status = Command::new(&bindgen) 64 .args(["generate", "--library"]) 65 .arg(&library) 66 .args(["--language", language, "--no-format", "--out-dir"]) 67 .arg(&generated) 68 .current_dir(source_root) 69 .status() 70 .map_err(|error| format!("failed to start {}: {error}", bindgen.display()))?; 71 if !status.success() { 72 return Err(format!( 73 "{language} binding generation failed with {status}" 74 )); 75 } 76 install_outputs(source_root, consumer_root, language, &generated, mode)?; 77 println!("generated {language} bindings for {FFI_PACKAGE}"); 78 Ok(()) 79 } 80 81 fn build_bindgen(root: &Path) -> Result<(), String> { 82 let cargo = env::var_os("CARGO").unwrap_or_else(|| "cargo".into()); 83 for args in [ 84 vec!["build", "--locked", "-p", FFI_PACKAGE, "--lib"], 85 vec!["build", "--locked", "-p", "xtask", "--bin", BINDGEN], 86 ] { 87 let status = Command::new(&cargo) 88 .args(args) 89 .current_dir(root) 90 .status() 91 .map_err(|error| format!("failed to start Cargo for FFI generation: {error}"))?; 92 if !status.success() { 93 return Err(format!( 94 "FFI library and bindgen build failed with {status}" 95 )); 96 } 97 } 98 Ok(()) 99 } 100 101 fn install_outputs( 102 source_root: &Path, 103 consumer_root: &Path, 104 language: &str, 105 temporary: &Path, 106 mode: Mode, 107 ) -> Result<(), String> { 108 let output_dir = consumer_root.join("generated").join(language); 109 let mut generated = Vec::new(); 110 collect_files(temporary, &mut generated)?; 111 generated.sort(); 112 let mut outputs = BTreeMap::new(); 113 for path in generated { 114 let name = path 115 .strip_prefix(temporary) 116 .map_err(|error| format!("failed to relativize {}: {error}", path.display()))? 117 .to_str() 118 .ok_or_else(|| format!("non-UTF-8 generated binding path: {}", path.display()))? 119 .replace('\\', "/"); 120 let contents = fs::read(&path) 121 .map_err(|error| format!("failed to read {}: {error}", path.display()))?; 122 let destination = output_dir.join(&name); 123 let text = String::from_utf8(contents) 124 .map_err(|error| format!("generated text binding is not UTF-8: {error}"))?; 125 let text = normalize_generated_text(&text); 126 outputs.insert( 127 name.clone(), 128 format!("{:x}", Sha256::digest(text.as_bytes())), 129 ); 130 write_or_check(&destination, &text, mode)?; 131 } 132 if outputs.is_empty() { 133 return Err(format!("{language} binding generator emitted no files")); 134 } 135 let notice_hash = 136 crate::generate::data_notices::install(source_root, &output_dir.join("NOTICE"), mode)?; 137 outputs.insert("NOTICE".to_owned(), notice_hash); 138 let lock = SourceLock { 139 schema_version: 1, 140 source_package: FFI_PACKAGE.to_owned(), 141 source_version: FFI_VERSION.to_owned(), 142 source_sha256: ffi_source_sha256(source_root)?, 143 generator: BINDGEN.to_owned(), 144 generator_version: BINDGEN_VERSION.to_owned(), 145 language: language.to_owned(), 146 outputs, 147 }; 148 let mut rendered = serde_json::to_string_pretty(&lock) 149 .map_err(|error| format!("failed to render {language} source lock: {error}"))?; 150 rendered.push('\n'); 151 write_or_check(&output_dir.join("source.lock"), &rendered, mode) 152 } 153 154 fn normalize_generated_text(contents: &str) -> String { 155 let mut normalized = contents 156 .lines() 157 .map(str::trim_end) 158 .collect::<Vec<_>>() 159 .join("\n"); 160 while normalized.ends_with('\n') { 161 normalized.pop(); 162 } 163 normalized.push('\n'); 164 normalized 165 } 166 167 pub fn check_generated_language( 168 source_root: &Path, 169 consumer_root: &Path, 170 language: &str, 171 ) -> Result<(), String> { 172 match language { 173 "swift" => check_language( 174 source_root, 175 consumer_root, 176 "swift", 177 &[ 178 "radroots_sdk.swift", 179 "radroots_sdkFFI.h", 180 "radroots_sdkFFI.modulemap", 181 ], 182 ), 183 "kotlin" => { 184 check_language( 185 source_root, 186 consumer_root, 187 "kotlin", 188 &["uniffi/radroots_sdk/radroots_sdk.kt"], 189 )?; 190 check_kotlin_schema_inventory(consumer_root) 191 } 192 _ => Err("SDK binding language must be swift or kotlin".to_owned()), 193 } 194 } 195 196 fn check_kotlin_schema_inventory(root: &Path) -> Result<(), String> { 197 let path = root.join("generated/kotlin/uniffi/radroots_sdk/radroots_sdk.kt"); 198 let source = fs::read_to_string(&path) 199 .map_err(|error| format!("failed to read {}: {error}", path.display()))?; 200 for required in [ 201 "class MobileClient", 202 "data class CapabilityStatus", 203 "enum class CapabilityAvailability", 204 "enum class CapabilityMaturity", 205 "sealed class Exception", 206 ] { 207 if !source.contains(required) { 208 return Err(format!( 209 "generated Kotlin schema inventory is missing {required}: {}", 210 path.display() 211 )); 212 } 213 } 214 for forbidden in ["Keychain", "BackgroundTask", "Presentation"] { 215 if source.contains(forbidden) { 216 return Err(format!( 217 "generated Kotlin bindings contain host-owned {forbidden} API: {}", 218 path.display() 219 )); 220 } 221 } 222 Ok(()) 223 } 224 225 fn check_language( 226 source_root: &Path, 227 consumer_root: &Path, 228 language: &str, 229 expected: &[&str], 230 ) -> Result<(), String> { 231 let output_dir = consumer_root.join("generated").join(language); 232 let mut actual_paths = Vec::new(); 233 collect_files(&output_dir, &mut actual_paths)?; 234 let actual = actual_paths 235 .into_iter() 236 .map(|path| { 237 path.strip_prefix(&output_dir) 238 .map(|relative| relative.to_string_lossy().replace('\\', "/")) 239 .map_err(|error| format!("failed to relativize {}: {error}", path.display())) 240 }) 241 .collect::<Result<BTreeSet<_>, _>>()?; 242 let expected_inventory = expected 243 .iter() 244 .map(|name| (*name).to_owned()) 245 .chain(["source.lock".to_owned(), "NOTICE".to_owned()]) 246 .collect::<BTreeSet<_>>(); 247 if actual != expected_inventory { 248 return Err(format!( 249 "unexpected generated {language} binding inventory: expected {expected_inventory:?}, found {actual:?}" 250 )); 251 } 252 let lock_path = output_dir.join("source.lock"); 253 let raw = fs::read_to_string(&lock_path) 254 .map_err(|error| format!("failed to read {}: {error}", lock_path.display()))?; 255 let actual: SourceLock = serde_json::from_str(&raw) 256 .map_err(|error| format!("failed to parse {}: {error}", lock_path.display()))?; 257 let mut outputs = BTreeMap::new(); 258 for name in expected { 259 let path = output_dir.join(name); 260 let contents = fs::read(&path) 261 .map_err(|error| format!("failed to read {}: {error}", path.display()))?; 262 outputs.insert( 263 (*name).to_owned(), 264 format!("{:x}", Sha256::digest(contents)), 265 ); 266 } 267 let notice_hash = crate::generate::data_notices::install( 268 source_root, 269 &output_dir.join("NOTICE"), 270 Mode::Check, 271 )?; 272 outputs.insert("NOTICE".to_owned(), notice_hash); 273 let expected_lock = SourceLock { 274 schema_version: 1, 275 source_package: FFI_PACKAGE.to_owned(), 276 source_version: FFI_VERSION.to_owned(), 277 source_sha256: ffi_source_sha256(source_root)?, 278 generator: BINDGEN.to_owned(), 279 generator_version: BINDGEN_VERSION.to_owned(), 280 language: language.to_owned(), 281 outputs, 282 }; 283 if actual != expected_lock { 284 return Err(format!( 285 "stale generated {language} bindings: {}", 286 lock_path.display() 287 )); 288 } 289 Ok(()) 290 } 291 292 fn ffi_source_sha256(root: &Path) -> Result<String, String> { 293 let crate_dir = root.join("crates/sdk_ffi"); 294 let mut paths = vec![crate_dir.join("Cargo.toml"), crate_dir.join("README.md")]; 295 collect_files(&crate_dir.join("src"), &mut paths)?; 296 paths.push(root.join("tools/xtask/src/sdk_generation/bindings.rs")); 297 paths.push(root.join("tools/xtask/src/generate/data_notices.rs")); 298 paths.push(root.join(crate::generate::data_notices::CONTRACT)); 299 paths.push(root.join(crate::generate::data_notices::OUTPUT)); 300 collect_files( 301 &root.join("tools/xtask/src/bin/radroots_ffi_bindgen"), 302 &mut paths, 303 )?; 304 paths.sort(); 305 let mut hasher = Sha256::new(); 306 for path in paths { 307 let relative = path 308 .strip_prefix(root) 309 .map_err(|error| format!("failed to relativize {}: {error}", path.display()))?; 310 hasher.update(relative.to_string_lossy().as_bytes()); 311 hasher.update([0]); 312 hasher.update( 313 fs::read(&path) 314 .map_err(|error| format!("failed to read {}: {error}", path.display()))?, 315 ); 316 hasher.update([0]); 317 } 318 Ok(format!("{:x}", hasher.finalize())) 319 } 320 321 fn collect_files(dir: &Path, paths: &mut Vec<PathBuf>) -> Result<(), String> { 322 let mut entries = fs::read_dir(dir) 323 .map_err(|error| format!("failed to read {}: {error}", dir.display()))? 324 .collect::<Result<Vec<_>, _>>() 325 .map_err(|error| format!("failed to enumerate {}: {error}", dir.display()))?; 326 entries.sort_by_key(std::fs::DirEntry::file_name); 327 for entry in entries { 328 let path = entry.path(); 329 if path.is_dir() { 330 collect_files(&path, paths)?; 331 } else if path.is_file() { 332 paths.push(path); 333 } 334 } 335 Ok(()) 336 } 337 338 #[cfg(test)] 339 mod tests { 340 use std::{collections::BTreeMap, fs}; 341 342 use sha2::{Digest, Sha256}; 343 344 use crate::build_control::Mode; 345 346 use super::{ 347 BINDGEN, BINDGEN_VERSION, FFI_PACKAGE, FFI_VERSION, SourceLock, check_generated_language, 348 ffi_source_sha256, generate, 349 }; 350 351 #[test] 352 fn language_check_does_not_require_the_other_binding_tree() { 353 let consumer = tempfile::TempDir::new().expect("consumer fixture"); 354 let source = crate::workspace_root(); 355 let output_dir = consumer.path().join("generated/swift"); 356 fs::create_dir_all(&output_dir).expect("Swift output directory"); 357 let mut outputs = BTreeMap::from([ 358 ("radroots_sdk.swift".to_owned(), "swift\n"), 359 ("radroots_sdkFFI.h".to_owned(), "header\n"), 360 ("radroots_sdkFFI.modulemap".to_owned(), "module\n"), 361 ]); 362 for (name, contents) in &outputs { 363 fs::write(output_dir.join(name), contents).expect("Swift fixture output"); 364 } 365 let material = crate::generate::data_notices::render(&source).unwrap(); 366 fs::write(output_dir.join("NOTICE"), &material).unwrap(); 367 outputs.insert("NOTICE".to_owned(), material.as_str()); 368 let lock = SourceLock { 369 schema_version: 1, 370 source_package: FFI_PACKAGE.to_owned(), 371 source_version: FFI_VERSION.to_owned(), 372 source_sha256: ffi_source_sha256(&source).expect("FFI source digest"), 373 generator: BINDGEN.to_owned(), 374 generator_version: BINDGEN_VERSION.to_owned(), 375 language: "swift".to_owned(), 376 outputs: outputs 377 .into_iter() 378 .map(|(name, contents)| { 379 (name, format!("{:x}", Sha256::digest(contents.as_bytes()))) 380 }) 381 .collect(), 382 }; 383 let mut rendered = serde_json::to_string_pretty(&lock).expect("source lock"); 384 rendered.push('\n'); 385 fs::write(output_dir.join("source.lock"), rendered).expect("source lock fixture"); 386 387 check_generated_language(&source, consumer.path(), "swift").expect("Swift-only validation"); 388 assert!(check_generated_language(&source, consumer.path(), "kotlin").is_err()); 389 } 390 391 #[test] 392 #[ignore = "requires the native UniFFI bindgen toolchain"] 393 fn canonical_bindgen_matches_the_frozen_sdk_surface() { 394 let consumer = tempfile::TempDir::new().expect("consumer fixture"); 395 let source = crate::workspace_root(); 396 generate(&source, consumer.path(), "swift", Mode::Write).expect("Swift generation"); 397 generate(&source, consumer.path(), "kotlin", Mode::Write).expect("Kotlin generation"); 398 check_generated_language(&source, consumer.path(), "swift").expect("fresh Swift bindings"); 399 check_generated_language(&source, consumer.path(), "kotlin") 400 .expect("fresh Kotlin bindings"); 401 402 let expected = BTreeMap::from([ 403 ( 404 "generated/swift/radroots_sdk.swift", 405 "232932067903afb88fdb6f30714a35ef688b691da23b12ff98c07afdba3a3109", 406 ), 407 ( 408 "generated/swift/radroots_sdkFFI.h", 409 "03601cc25edbd4d3098460c828a55009b788cbf787864983f974db22db1e47e0", 410 ), 411 ( 412 "generated/swift/radroots_sdkFFI.modulemap", 413 "b18fa5af1567a940fc699afe371a3a4653dca206f3233bcdf322062ab8192170", 414 ), 415 ( 416 "generated/kotlin/uniffi/radroots_sdk/radroots_sdk.kt", 417 "7d7a4955138d226ed0a73bb9070e34c585be4c2d11cc8e9b4f430ccbbebbfc55", 418 ), 419 ]); 420 for (relative, expected_sha256) in expected { 421 let bytes = fs::read(consumer.path().join(relative)).expect("generated binding"); 422 assert_eq!( 423 format!("{:x}", Sha256::digest(bytes)), 424 expected_sha256, 425 "generated SDK binding {relative}" 426 ); 427 } 428 } 429 }