maintainers/scripts/convert-to-import-cargo-lock/src/main.rs

   1 #![warn(clippy::pedantic)]
   2 #![allow(clippy::too_many_lines)]
   3
   4 use anyhow::anyhow;
   5 use serde::Deserialize;
   6 use std::{collections::HashMap, env, fs, path::PathBuf, process::Command};
   7
   8 #[derive(Deserialize)]
   9 struct CargoLock<'a> {
  10     #[serde(rename = "package", borrow)]
  11     packages: Vec<Package<'a>>,
  12     metadata: Option<HashMap<&'a str, &'a str>>,
  13 }
  14
  15 #[derive(Deserialize)]
  16 struct Package<'a> {
  17     name: &'a str,
  18     version: &'a str,
  19     source: Option<&'a str>,
  20     checksum: Option<&'a str>,
  21 }
  22
  23 #[derive(Deserialize)]
  24 struct PrefetchOutput {
  25     sha256: String,
  26 }
  27
  28 fn main() -> anyhow::Result<()> {
  29     let mut hashes = HashMap::new();
  30
  31     let attr_count = env::args().len() - 1;
  32
  33     for (i, attr) in env::args().skip(1).enumerate() {
  34         println!("converting {attr} ({}/{attr_count})", i + 1);
  35
  36         convert(&attr, &mut hashes)?;
  37     }
  38
  39     Ok(())
  40 }
  41
  42 fn convert(attr: &str, hashes: &mut HashMap<String, String>) -> anyhow::Result<()> {
  43     let package_path = nix_eval(format!("{attr}.meta.position"))?
  44         .and_then(|p| p.split_once(':').map(|(f, _)| PathBuf::from(f)));
  45
  46     if package_path.is_none() {
  47         eprintln!("can't automatically convert {attr}: doesn't exist");
  48         return Ok(());
  49     }
  50
  51     let package_path = package_path.unwrap();
  52
  53     if package_path.with_file_name("Cargo.lock").exists() {
  54         eprintln!("skipping {attr}: already has a vendored Cargo.lock");
  55         return Ok(());
  56     }
  57
  58     let mut src = PathBuf::from(
  59         String::from_utf8(
  60             Command::new("nix-build")
  61                 .arg("-A")
  62                 .arg(format!("{attr}.src"))
  63                 .output()?
  64                 .stdout,
  65         )?
  66         .trim(),
  67     );
  68
  69     if !src.exists() {
  70         eprintln!("can't automatically convert {attr}: src doesn't exist (bad attr?)");
  71         return Ok(());
  72     } else if !src.metadata()?.is_dir() {
  73         eprintln!("can't automatically convert {attr}: src isn't a directory");
  74         return Ok(());
  75     }
  76
  77     if let Some(mut source_root) = nix_eval(format!("{attr}.sourceRoot"))?.map(PathBuf::from) {
  78         source_root = source_root.components().skip(1).collect();
  79         src.push(source_root);
  80     }
  81
  82     let cargo_lock_path = src.join("Cargo.lock");
  83
  84     if !cargo_lock_path.exists() {
  85         eprintln!("can't automatically convert {attr}: src doesn't contain Cargo.lock");
  86         return Ok(());
  87     }
  88
  89     let cargo_lock_content = fs::read_to_string(cargo_lock_path)?;
  90
  91     let cargo_lock: CargoLock = basic_toml::from_str(&cargo_lock_content)?;
  92
  93     let mut git_dependencies = Vec::new();
  94
  95     for package in cargo_lock.packages.iter().filter(|p| {
  96         p.source.is_some()
  97             && p.checksum
  98                 .or_else(|| {
  99                     cargo_lock
 100                         .metadata
 101                         .as_ref()?
 102                         .get(
 103                             format!("checksum {} {} ({})", p.name, p.version, p.source.unwrap())
 104                                 .as_str(),
 105                         )
 106                         .copied()
 107                 })
 108                 .is_none()
 109     }) {
 110         let (typ, original_url) = package
 111             .source
 112             .unwrap()
 113             .split_once('+')
 114             .expect("dependency should have well-formed source url");
 115
 116         if let Some(hash) = hashes.get(original_url) {
 117             continue;
 118         }
 119
 120         assert_eq!(
 121             typ, "git",
 122             "packages without checksums should be git dependencies"
 123         );
 124
 125         let (mut url, rev) = original_url
 126             .split_once('#')
 127             .expect("git dependency should have commit");
 128
 129         // TODO: improve
 130         if let Some((u, _)) = url.split_once('?') {
 131             url = u;
 132         }
 133
 134         let prefetch_output: PrefetchOutput = serde_json::from_slice(
 135             &Command::new("nix-prefetch-git")
 136                 .args(["--url", url, "--rev", rev, "--quiet", "--fetch-submodules"])
 137                 .output()?
 138                 .stdout,
 139         )?;
 140
 141         let output_hash = String::from_utf8(
 142             Command::new("nix")
 143                 .args([
 144                     "--extra-experimental-features",
 145                     "nix-command",
 146                     "hash",
 147                     "to-sri",
 148                     "--type",
 149                     "sha256",
 150                     &prefetch_output.sha256,
 151                 ])
 152                 .output()?
 153                 .stdout,
 154         )?;
 155
 156         let hash = output_hash.trim().to_string();
 157
 158         git_dependencies.push((
 159             format!("{}-{}", package.name, package.version),
 160             output_hash.trim().to_string().clone(),
 161         ));
 162
 163         hashes.insert(original_url.to_string(), hash);
 164     }
 165
 166     fs::write(
 167         package_path.with_file_name("Cargo.lock"),
 168         cargo_lock_content,
 169     )?;
 170
 171     let mut package_lines: Vec<_> = fs::read_to_string(&package_path)?
 172         .lines()
 173         .map(String::from)
 174         .collect();
 175
 176     let (cargo_deps_line_index, cargo_deps_line) = package_lines
 177         .iter_mut()
 178         .enumerate()
 179         .find(|(_, l)| {
 180             l.trim_start().starts_with("cargoHash") || l.trim_start().starts_with("cargoSha256")
 181         })
 182         .expect("package should contain cargoHash/cargoSha256");
 183
 184     let spaces = " ".repeat(cargo_deps_line.len() - cargo_deps_line.trim_start().len());
 185
 186     if git_dependencies.is_empty() {
 187         *cargo_deps_line = format!("{spaces}cargoLock.lockFile = ./Cargo.lock;");
 188     } else {
 189         *cargo_deps_line = format!("{spaces}cargoLock = {{");
 190
 191         let mut index_iter = cargo_deps_line_index + 1..;
 192
 193         package_lines.insert(
 194             index_iter.next().unwrap(),
 195             format!("{spaces}  lockFile = ./Cargo.lock;"),
 196         );
 197
 198         package_lines.insert(
 199             index_iter.next().unwrap(),
 200             format!("{spaces}  outputHashes = {{"),
 201         );
 202
 203         for ((dep, hash), index) in git_dependencies.drain(..).zip(&mut index_iter) {
 204             package_lines.insert(index, format!("{spaces}    {dep:?} = {hash:?};"));
 205         }
 206
 207         package_lines.insert(index_iter.next().unwrap(), format!("{spaces}  }};"));
 208         package_lines.insert(index_iter.next().unwrap(), format!("{spaces}}};"));
 209     }
 210
 211     if package_lines.last().map(String::as_str) != Some("") {
 212         package_lines.push(String::new());
 213     }
 214
 215     fs::write(package_path, package_lines.join("\n"))?;
 216
 217     Ok(())
 218 }
 219
 220 fn nix_eval(attr: impl AsRef<str>) -> anyhow::Result<Option<String>> {
 221     let output = String::from_utf8(
 222         Command::new("nix-instantiate")
 223             .args(["--eval", "-A", attr.as_ref()])
 224             .output()?
 225             .stdout,
 226     )?;
 227
 228     let trimmed = output.trim();
 229
 230     if trimmed.is_empty() || trimmed == "null" {
 231         Ok(None)
 232     } else {
 233         Ok(Some(
 234             trimmed
 235                 .strip_prefix('"')
 236                 .and_then(|p| p.strip_suffix('"'))
 237                 .ok_or_else(|| anyhow!("couldn't parse nix-instantiate output: {output:?}"))?
 238                 .to_string(),
 239         ))
 240     }
 241 }