sergio/takana

1//! Fase `fetch`: materializa el árbol fuente de la receta en un directorio trabajable.
2//!
3//! Dos modos, decididos por la receta (ver `hammer_core::SourceKind`):
4//!
5//! * **Git** — mirror local en `<work_root>/repos/<name>.git` + `git archive` del commit
6//!   fijado al árbol trabajable. El mirror se reusa entre builds; el árbol es descartable.
7//! * **Tarball** — descarga con `curl`, verificación de sha256, extracción con `tar`. Se
8//!   cachean los archivos descargados en `<work_root>/tarballs/`.
9//!
10//! La red sólo se permite aquí, FUERA del sandbox de build. Después del fetch, el árbol del
11//! source se copia a un dir descartable y se aplican los patches; el sandbox sólo ve esa
12//! copia (sin red).
13
14use std::path::{Path, PathBuf};
15use std::process::{Command, Stdio};
16
17use hammer_core::{Recipe, SourceKind};
18
19/// Materializa el árbol fuente en un directorio trabajable y devuelve su ruta.
20pub fn fetch(recipe: &Recipe, work_root: &Path) -> hammer_core::Result<PathBuf> {
21    match recipe.source.kind()? {
22        SourceKind::Git { repo, commit } => fetch_git(recipe, repo, commit, work_root),
23        SourceKind::Tarball { url, sha256 } => fetch_tarball(recipe, url, sha256, work_root),
24    }
25}
26
27fn fetch_git(
28    recipe: &Recipe,
29    repo: &str,
30    commit: &str,
31    work_root: &Path,
32) -> hammer_core::Result<PathBuf> {
33    let repos_dir = work_root.join("repos");
34    let sources_dir = work_root.join("sources");
35    std::fs::create_dir_all(&repos_dir)?;
36    std::fs::create_dir_all(&sources_dir)?;
37
38    let mirror = repos_dir.join(format!("{}.git", recipe.name));
39    if !mirror.is_dir() {
40        run_git(
41            &[
42                "clone",
43                "--mirror",
44                "--filter=blob:none",
45                repo,
46                mirror.to_str().unwrap(),
47            ],
48            None,
49        )?;
50    }
51
52    // Asegura que tenemos el commit pedido. En un mirror existente puede faltar.
53    if run_git(&["cat-file", "-e", commit], Some(&mirror)).is_err() {
54        run_git(&["fetch", "--all", "--tags"], Some(&mirror))?;
55        run_git(&["cat-file", "-e", commit], Some(&mirror)).map_err(|_| {
56            hammer_core::Error::Other(anyhow::anyhow!(
57                "commit {commit} no existe en {repo} tras fetch"
58            ))
59        })?;
60    }
61
62    // Materializa un árbol trabajable mediante `git archive` → tar → extract.
63    // Esto evita el coste de un worktree completo y deja sólo los archivos del commit.
64    let work_tree = sources_dir.join(format!("{}-{}", recipe.name, commit));
65    if work_tree.is_dir() {
66        std::fs::remove_dir_all(&work_tree)?;
67    }
68    std::fs::create_dir_all(&work_tree)?;
69
70    let archive = Command::new("git")
71        .arg("-C")
72        .arg(&mirror)
73        .args(["archive", "--format=tar", commit])
74        .stdout(Stdio::piped())
75        .stderr(Stdio::piped())
76        .spawn()
77        .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn git archive: {e}")))?;
78
79    let tar_status = Command::new("tar")
80        .args(["-x", "-C"])
81        .arg(&work_tree)
82        .stdin(archive.stdout.unwrap())
83        .stdout(Stdio::inherit())
84        .stderr(Stdio::inherit())
85        .status()
86        .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn tar -x: {e}")))?;
87
88    if !tar_status.success() {
89        return Err(hammer_core::Error::Other(anyhow::anyhow!(
90            "git archive | tar -x falló (tar exit {:?})",
91            tar_status.code()
92        )));
93    }
94    Ok(work_tree)
95}
96
97fn fetch_tarball(
98    recipe: &Recipe,
99    url: &str,
100    sha256: &str,
101    work_root: &Path,
102) -> hammer_core::Result<PathBuf> {
103    let tarballs_dir = work_root.join("tarballs");
104    let sources_dir = work_root.join("sources");
105    std::fs::create_dir_all(&tarballs_dir)?;
106    std::fs::create_dir_all(&sources_dir)?;
107
108    // Nombre por hash: dos URLs distintas con el mismo contenido se cachean una vez, y
109    // cambiar la URL sin cambiar el sha (mirror) no invalida la caché.
110    let cached = tarballs_dir.join(format!("{sha256}.tar"));
111    if !cached.is_file() {
112        download_verify(url, sha256, &cached)?;
113    } else {
114        verify_sha256(&cached, sha256)?;
115    }
116
117    let work_tree = sources_dir.join(format!("{}-{}", recipe.name, &sha256[..16]));
118    if work_tree.is_dir() {
119        std::fs::remove_dir_all(&work_tree)?;
120    }
121    std::fs::create_dir_all(&work_tree)?;
122
123    // `tar` autodetecta el compresor por la cabecera; el sufijo .tar del nombre es solo
124    // identificador interno (no afecta a la detección).
125    let strip = recipe.source.strip_components.to_string();
126    let status = Command::new("tar")
127        .arg("-x")
128        .arg("-f")
129        .arg(&cached)
130        .arg("--strip-components")
131        .arg(&strip)
132        .arg("-C")
133        .arg(&work_tree)
134        .stdout(Stdio::inherit())
135        .stderr(Stdio::inherit())
136        .status()
137        .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn tar -x tarball: {e}")))?;
138    if !status.success() {
139        return Err(hammer_core::Error::Other(anyhow::anyhow!(
140            "tar -x falló (exit {:?})",
141            status.code()
142        )));
143    }
144    Ok(work_tree)
145}
146
147/// Descarga `url` a `dst` y verifica el sha256. Si la verificación falla, borra el archivo
148/// para que la próxima corrida lo vuelva a intentar (no envenenamos la caché).
149fn download_verify(url: &str, sha256: &str, dst: &Path) -> hammer_core::Result<()> {
150    let tmp = dst.with_extension("tar.partial");
151    let status = Command::new("curl")
152        .args(["-fL", "--retry", "3", "--connect-timeout", "30", "-o"])
153        .arg(&tmp)
154        .arg(url)
155        .stdout(Stdio::inherit())
156        .stderr(Stdio::inherit())
157        .status()
158        .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn curl: {e}")))?;
159    if !status.success() {
160        let _ = std::fs::remove_file(&tmp);
161        return Err(hammer_core::Error::Other(anyhow::anyhow!(
162            "curl {url} falló (exit {:?})",
163            status.code()
164        )));
165    }
166    if let Err(e) = verify_sha256(&tmp, sha256) {
167        let _ = std::fs::remove_file(&tmp);
168        return Err(e);
169    }
170    std::fs::rename(&tmp, dst)?;
171    Ok(())
172}
173
174fn verify_sha256(path: &Path, expected: &str) -> hammer_core::Result<()> {
175    use sha2::{Digest, Sha256};
176    let mut f = std::fs::File::open(path)?;
177    let mut hasher = Sha256::new();
178    std::io::copy(&mut f, &mut hasher)?;
179    let got = hex::encode(hasher.finalize());
180    if !got.eq_ignore_ascii_case(expected) {
181        return Err(hammer_core::Error::Other(anyhow::anyhow!(
182            "sha256 mismatch en {}: esperado {expected}, obtenido {got}",
183            path.display()
184        )));
185    }
186    Ok(())
187}
188
189/// Vendoriza las dependencias de un proyecto Cargo en `<src>/vendor` y escribe
190/// `<src>/.cargo/config.toml` para que el build dentro del sandbox resuelva todo `--offline`.
191///
192/// La red se usa AQUÍ (fuera del sandbox, como el resto del fetch). `--locked` fija las versiones
193/// por el `Cargo.lock` del source: mismo commit ⇒ mismo lock ⇒ mismas deps vendoreadas, así que
194/// el vendoring no introduce no-determinismo (el `Cargo.lock` ya está dentro del commit que hashea
195/// la receta). Un crate sin deps de crates.io produce un config vacío y ningún `vendor/`: inocuo.
196pub fn vendor_cargo_deps(src: &Path) -> hammer_core::Result<()> {
197    let output = Command::new("cargo")
198        .current_dir(src)
199        .args(["vendor", "--locked", "vendor"])
200        .stderr(Stdio::inherit())
201        .output()
202        .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn cargo vendor: {e}")))?;
203    if !output.status.success() {
204        return Err(hammer_core::Error::Other(anyhow::anyhow!(
205            "cargo vendor falló (exit {:?})",
206            output.status.code()
207        )));
208    }
209    // `cargo vendor` emite por stdout el fragmento `[source.*]` a instalar; lo persistimos en el
210    // árbol del source para que `cargo build --offline` lo lea (ruta relativa `vendor`, que
211    // resuelve igual dentro del sandbox donde el source se monta en /src).
212    let cargo_dir = src.join(".cargo");
213    std::fs::create_dir_all(&cargo_dir)?;
214    std::fs::write(cargo_dir.join("config.toml"), &output.stdout)?;
215    Ok(())
216}
217
218/// Aplica los patches de la receta (relativos a `recipe.base_dir`) sobre `tree`.
219pub fn apply_patches(recipe: &Recipe, tree: &Path) -> hammer_core::Result<()> {
220    for p in &recipe.source.patches {
221        let patch_path = recipe.base_dir.join(p);
222        let bytes = std::fs::read(&patch_path).map_err(|e| {
223            hammer_core::Error::Recipe(format!(
224                "no pude leer patch {}: {e}",
225                patch_path.display()
226            ))
227        })?;
228        let mut child = Command::new("patch")
229            .args(["-p1", "--batch", "--silent"])
230            .current_dir(tree)
231            .stdin(Stdio::piped())
232            .stdout(Stdio::inherit())
233            .stderr(Stdio::inherit())
234            .spawn()
235            .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn patch: {e}")))?;
236        if let Some(mut stdin) = child.stdin.take() {
237            use std::io::Write;
238            stdin
239                .write_all(&bytes)
240                .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("write patch: {e}")))?;
241        }
242        let status = child
243            .wait()
244            .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("wait patch: {e}")))?;
245        if !status.success() {
246            return Err(hammer_core::Error::Other(anyhow::anyhow!(
247                "patch {} falló (exit {:?})",
248                patch_path.display(),
249                status.code()
250            )));
251        }
252    }
253    Ok(())
254}
255
256#[cfg(test)]
257mod tests {
258    use super::*;
259
260    #[test]
261    fn vendor_cargo_deps_runs_and_writes_config() {
262        // Crate sin deps de crates.io: `cargo vendor` sale 0 con config vacío y sin red.
263        // Verifica el camino spawn → captura stdout → escribe `.cargo/config.toml`.
264        let tmp = tempfile::tempdir().unwrap();
265        let src = tmp.path();
266        std::fs::write(
267            src.join("Cargo.toml"),
268            "[package]\nname = \"vt\"\nversion = \"0.0.0\"\nedition = \"2021\"\n\n[dependencies]\n",
269        )
270        .unwrap();
271        std::fs::create_dir_all(src.join("src")).unwrap();
272        std::fs::write(src.join("src/main.rs"), "fn main() {}").unwrap();
273
274        // `--locked` exige un Cargo.lock presente; lo generamos offline (sin deps).
275        let lock_ok = Command::new("cargo")
276            .args(["generate-lockfile", "--offline"])
277            .current_dir(src)
278            .status()
279            .map(|s| s.success())
280            .unwrap_or(false);
281        if !lock_ok {
282            eprintln!("SKIP: cargo no disponible para generate-lockfile");
283            return;
284        }
285
286        vendor_cargo_deps(src).unwrap();
287        assert!(src.join(".cargo/config.toml").is_file(), "debe escribir el config de vendoring");
288    }
289}
290
291fn run_git(args: &[&str], cwd: Option<&Path>) -> hammer_core::Result<()> {
292    let mut cmd = Command::new("git");
293    if let Some(c) = cwd {
294        cmd.arg("-C").arg(c);
295    }
296    cmd.args(args);
297    let status = cmd
298        .stdin(Stdio::null())
299        .stdout(Stdio::inherit())
300        .stderr(Stdio::inherit())
301        .status()
302        .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn git {args:?}: {e}")))?;
303    if !status.success() {
304        return Err(hammer_core::Error::Other(anyhow::anyhow!(
305            "git {args:?} falló (exit {:?})",
306            status.code()
307        )));
308    }
309    Ok(())
310}