lib

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

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 }