radrootsd

JSON-RPC bridge for Radroots event publishing
git clone https://radroots.dev/git/radrootsd.git
Log | Files | Refs | README | LICENSE

source_lock.rs (9930B)


      1 use serde::{Deserialize, Serialize};
      2 use serde_json::Value;
      3 use sha2::{Digest, Sha256};
      4 use std::{fs, io::Write, path::Path, process::Command};
      5 
      6 const LOCK: &str = "radroots.lib.source-lock.v1.toml";
      7 
      8 #[derive(Debug, PartialEq)]
      9 pub(super) enum Error {
     10     Input,
     11     Graph,
     12     Stale,
     13     Io,
     14 }
     15 
     16 #[derive(Deserialize, Serialize)]
     17 #[serde(deny_unknown_fields)]
     18 struct SourceLock {
     19     schema: String,
     20     repository: String,
     21     revision: String,
     22     architecture: String,
     23     workspace_catalog_sha256: String,
     24     version: String,
     25     source_archive_sha256: String,
     26     lockfile: String,
     27     lockfile_sha256: String,
     28 }
     29 
     30 pub(super) fn run(arguments: &[String]) -> Result<(), Error> {
     31     let [action] = arguments else {
     32         return Err(Error::Input);
     33     };
     34     if !matches!(action.as_str(), "check" | "refresh") {
     35         return Err(Error::Input);
     36     }
     37     let root = Path::new(env!("CARGO_MANIFEST_DIR"))
     38         .parent()
     39         .and_then(Path::parent)
     40         .ok_or(Error::Input)?;
     41     let source = read_bounded(&root.join(LOCK), 16 * 1024)?;
     42     let cargo_lock = read_bounded(&root.join("Cargo.lock"), 32 * 1024 * 1024)?;
     43     let output = Command::new("cargo")
     44         .args(["metadata", "--locked", "--offline", "--format-version", "1"])
     45         .current_dir(root)
     46         .output()
     47         .map_err(|_| Error::Io)?;
     48     if !output.status.success() || output.stdout.len() > 16 * 1024 * 1024 {
     49         return Err(Error::Graph);
     50     }
     51     let metadata = serde_json::from_slice(&output.stdout).map_err(|_| Error::Graph)?;
     52     let refreshed = render(&source, &cargo_lock, &metadata)?;
     53     if action == "check" {
     54         let original: SourceLock =
     55             toml::from_str(std::str::from_utf8(&source).map_err(|_| Error::Input)?)
     56                 .map_err(|_| Error::Input)?;
     57         if original.lockfile_sha256 != digest(&cargo_lock) {
     58             return Err(Error::Stale);
     59         }
     60         println!("source lock current");
     61         return Ok(());
     62     }
     63     let mut temporary = tempfile::NamedTempFile::new_in(root).map_err(|_| Error::Io)?;
     64     temporary
     65         .write_all(refreshed.as_bytes())
     66         .map_err(|_| Error::Io)?;
     67     temporary.as_file().sync_all().map_err(|_| Error::Io)?;
     68     if read_bounded(&root.join(LOCK), 16 * 1024)? != source
     69         || read_bounded(&root.join("Cargo.lock"), 32 * 1024 * 1024)? != cargo_lock
     70     {
     71         return Err(Error::Stale);
     72     }
     73     let permissions = fs::metadata(root.join(LOCK))
     74         .map_err(|_| Error::Io)?
     75         .permissions();
     76     temporary
     77         .as_file()
     78         .set_permissions(permissions)
     79         .map_err(|_| Error::Io)?;
     80     temporary.persist(root.join(LOCK)).map_err(|_| Error::Io)?;
     81     println!("source lock refreshed");
     82     Ok(())
     83 }
     84 
     85 fn read_bounded(path: &Path, limit: u64) -> Result<Vec<u8>, Error> {
     86     let metadata = fs::symlink_metadata(path).map_err(|_| Error::Io)?;
     87     if !metadata.is_file() || metadata.len() > limit {
     88         return Err(Error::Input);
     89     }
     90     let bytes = fs::read(path).map_err(|_| Error::Io)?;
     91     if bytes.len() as u64 > limit {
     92         return Err(Error::Input);
     93     }
     94     Ok(bytes)
     95 }
     96 
     97 fn digest(bytes: &[u8]) -> String {
     98     format!("{:x}", Sha256::digest(bytes))
     99 }
    100 
    101 fn render(source: &[u8], cargo_lock: &[u8], metadata: &Value) -> Result<String, Error> {
    102     let mut lock: SourceLock =
    103         toml::from_str(std::str::from_utf8(source).map_err(|_| Error::Input)?)
    104             .map_err(|_| Error::Input)?;
    105     if lock.schema != "radroots.lib.source-lock.v1"
    106         || lock.repository != "https://github.com/radrootslabs/lib"
    107         || lock.architecture != "radroots.crates.release.v2"
    108         || lock.lockfile != "Cargo.lock"
    109         || lock.version != "0.1.0-alpha"
    110     {
    111         return Err(Error::Input);
    112     }
    113     for (value, length) in [
    114         (&lock.revision, 40),
    115         (&lock.workspace_catalog_sha256, 64),
    116         (&lock.source_archive_sha256, 64),
    117         (&lock.lockfile_sha256, 64),
    118     ] {
    119         if value.len() != length
    120             || !value
    121                 .bytes()
    122                 .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
    123         {
    124             return Err(Error::Input);
    125         }
    126     }
    127     let source = format!(
    128         "git+https://github.com/radrootslabs/lib.git?rev={}",
    129         lock.revision
    130     );
    131     let resolved = format!("{source}#{}", lock.revision);
    132     let packages = metadata["packages"].as_array().ok_or(Error::Graph)?;
    133     let daemon = packages
    134         .iter()
    135         .find(|package| package["name"] == "radrootsd")
    136         .ok_or(Error::Graph)?;
    137     let dependencies = daemon["dependencies"].as_array().ok_or(Error::Graph)?;
    138     let mut direct = 0;
    139     for dependency in dependencies {
    140         let name = dependency["name"].as_str().ok_or(Error::Graph)?;
    141         if name.starts_with("radroots_") {
    142             if dependency["source"] != source
    143                 || dependency["req"] != format!("={}", lock.version)
    144                 || !dependency["rename"].is_null()
    145             {
    146                 return Err(Error::Graph);
    147             }
    148             direct += 1;
    149         }
    150     }
    151     let mut shared = 0;
    152     for package in packages {
    153         let name = package["name"].as_str().ok_or(Error::Graph)?;
    154         if name == "radroots" || name.starts_with("radroots_") {
    155             if package["source"] != resolved || package["version"] != lock.version {
    156                 return Err(Error::Graph);
    157             }
    158             shared += 1;
    159         }
    160     }
    161     if direct == 0 || shared == 0 {
    162         return Err(Error::Graph);
    163     }
    164     lock.lockfile_sha256 = digest(cargo_lock);
    165     toml::to_string(&lock).map_err(|_| Error::Input)
    166 }
    167 
    168 #[cfg(test)]
    169 mod tests {
    170     use super::*;
    171     use serde_json::json;
    172 
    173     fn fixture() -> (Vec<u8>, Value) {
    174         let source = include_bytes!("../../../radroots.lib.source-lock.v1.toml").to_vec();
    175         let lock: SourceLock =
    176             toml::from_str(std::str::from_utf8(&source).expect("UTF8")).expect("source lock");
    177         let git_source = format!(
    178             "git+https://github.com/radrootslabs/lib.git?rev={}",
    179             lock.revision
    180         );
    181         let metadata = json!({"packages": [
    182             {"name": "radrootsd", "dependencies": [{"name": "radroots_protocol", "source": git_source,
    183                 "req": "=0.1.0-alpha", "rename": null}]},
    184             {"name": "radroots_protocol", "source": format!("{git_source}#{}", lock.revision),
    185                 "version": "0.1.0-alpha"}
    186         ]});
    187         (source, metadata)
    188     }
    189 
    190     #[test]
    191     fn refresh_changes_only_actual_lock_digest_and_is_idempotent() {
    192         let (source, metadata) = fixture();
    193         let before: toml::Value =
    194             toml::from_str(std::str::from_utf8(&source).expect("UTF8")).expect("before");
    195         let refreshed = render(&source, b"new locked graph", &metadata).expect("refresh");
    196         let mut after: toml::Value = toml::from_str(&refreshed).expect("after");
    197         assert_eq!(
    198             after["lockfile_sha256"].as_str(),
    199             Some(digest(b"new locked graph").as_str())
    200         );
    201         after["lockfile_sha256"] = before["lockfile_sha256"].clone();
    202         assert_eq!(before, after);
    203         assert_eq!(
    204             render(refreshed.as_bytes(), b"new locked graph", &metadata).expect("replay"),
    205             refreshed
    206         );
    207     }
    208 
    209     #[test]
    210     fn duplicate_unknown_and_malformed_authority_is_rejected() {
    211         let (source, metadata) = fixture();
    212         for suffix in [
    213             "\nrevision = \"duplicate\"\n",
    214             "\nunknown = true\n",
    215             "\ninvalid = [",
    216         ] {
    217             let mut changed = source.clone();
    218             changed.extend_from_slice(suffix.as_bytes());
    219             assert_eq!(render(&changed, b"graph", &metadata), Err(Error::Input));
    220         }
    221         let changed = String::from_utf8(source)
    222             .expect("UTF8")
    223             .replace("lockfile = \"Cargo.lock\"", "lockfile = \"../Cargo.lock\"");
    224         assert_eq!(
    225             render(changed.as_bytes(), b"graph", &metadata),
    226             Err(Error::Input)
    227         );
    228     }
    229 
    230     #[test]
    231     fn direct_and_resolved_source_pin_version_or_alias_drift_is_rejected() {
    232         let (source, metadata) = fixture();
    233         for (field, value) in [
    234             ("source", Value::Null),
    235             ("req", json!("^0.1")),
    236             ("rename", json!("alias")),
    237         ] {
    238             let mut changed = metadata.clone();
    239             changed["packages"][0]["dependencies"][0][field] = value;
    240             assert_eq!(render(&source, b"graph", &changed), Err(Error::Graph));
    241         }
    242         for (field, value) in [("source", Value::Null), ("version", json!("0.2.0"))] {
    243             let mut changed = metadata.clone();
    244             changed["packages"][1][field] = value;
    245             assert_eq!(render(&source, b"graph", &changed), Err(Error::Graph));
    246         }
    247         assert_eq!(
    248             render(&source, b"graph", &json!({"packages": []})),
    249             Err(Error::Graph)
    250         );
    251     }
    252 
    253     #[test]
    254     fn oversized_or_non_regular_inputs_are_rejected() {
    255         let directory = tempfile::tempdir().expect("directory");
    256         let file = directory.path().join("input");
    257         fs::write(&file, b"12345").expect("input");
    258         assert_eq!(read_bounded(&file, 5).expect("bounded file"), b"12345");
    259         assert_eq!(read_bounded(&file, 4), Err(Error::Input));
    260         assert_eq!(read_bounded(directory.path(), 1024), Err(Error::Input));
    261         #[cfg(unix)]
    262         {
    263             let link = directory.path().join("link");
    264             std::os::unix::fs::symlink(&file, &link).expect("symlink");
    265             assert_eq!(read_bounded(&link, 5), Err(Error::Input));
    266         }
    267     }
    268 
    269     #[test]
    270     fn unsupported_commands_fail_before_graph_or_file_access() {
    271         for arguments in [
    272             vec![],
    273             vec!["write".to_owned()],
    274             vec!["refresh".to_owned(), "extra".to_owned()],
    275         ] {
    276             assert_eq!(run(&arguments), Err(Error::Input));
    277         }
    278     }
    279 }