{"header":{"message":"Some better error handling + implements gzipping packets + corrects bug with architecture name in ubuntu repos","description":null,"timestamp":"2026-02-04T15:06:05.732052098Z","authors":[{}]},"hash":"VK2LRA5ED6CWHXT4QZY2VT3KH5CSJTZ6OST2EZLCWQPVEK7LA2CQC","authors":[{"login":"Madx","key":"5GewrUUFjgxvfFXF5ECL1PHee2B3SKthxCg37jNfDZr9"}],"deps":{"hashes":[["VK2LRA5ED6CWHXT4QZY2VT3KH5CSJTZ6OST2EZLCWQPVEK7LA2CQC","Some better error handling + implements gzipping packets + corrects bug with architecture name in ubuntu repos"],["AA",null],["UWQB743KR36X6A6JVNK3VH6KMEFUHOUT6ZS2Y2SWIJR55JSF5WQAC","First working shell (with ocaml code)"],["2GMRXGVB4TIODHNVO53MLMSVTZW4TVWITZAGPFIH5CCHVHLOGHYAC","Some better error handling + implements gzipping packets + corrects bug with architecture name in ubuntu repos"],["AJLMC7UMTMBYBXLOSMGT5PDNX4D7O7LV4GDV7AN25CPOBPRUFYVAC","Forwarding log to frontend"],["ODUDDQRY373JMDR6W2BHUWSKEU6TEICQMNZIAIFKJPNUA5UN3C4QC","Adding the OCaml interface"],["LIMIMBOUN3DCIKKTHOK4TAXAWQXNVQXBTMNZYN22DJX4L4FZQH4AC","Bootstrapping the Rust part"]],"deps":["UWQB743KR36X6A6JVNK3VH6KMEFUHOUT6ZS2Y2SWIJR55JSF5WQAC","2GMRXGVB4TIODHNVO53MLMSVTZW4TVWITZAGPFIH5CCHVHLOGHYAC"],"known":["ODUDDQRY373JMDR6W2BHUWSKEU6TEICQMNZIAIFKJPNUA5UN3C4QC","AJLMC7UMTMBYBXLOSMGT5PDNX4D7O7LV4GDV7AN25CPOBPRUFYVAC","LIMIMBOUN3DCIKKTHOK4TAXAWQXNVQXBTMNZYN22DJX4L4FZQH4AC"]},"hunks":[{"FileDel":{"deleted_names":[{"basename":"deb.rs~","metadata":0}],"del":{"EdgeMap":{"edges":[{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":2,"pos":15},"to":{"change":3,"start":0,"end":31},"introduced_by":3},{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":3,"pos":31},"to":{"change":3,"start":32,"end":32},"introduced_by":3}],"inode":{"change":3,"pos":32}}},"content_edges":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":3,"pos":32},"to":{"change":3,"start":33,"end":22534},"introduced_by":3}],"inode":{"change":3,"pos":32}},"content":[{"Del":"use lazy_static::lazy_static;\nuse std::collections::HashMap;\nuse std::ffi::OsStr;\nuse std::io::{BufRead, BufReader, Read, Seek, SeekFrom};\nuse thiserror::*;\nuse tracing::*;\nmod index;\npub use index::*;\n\n/// A parsed .deb file.\n#[derive(Debug)]\npub struct Deb {\n md5sums: HashMap,\n control_file: String,\n _global: Header,\n _control: Header,\n data: Header,\n data_offset: u64,\n}\n\n/// A \"stanza\", i.e. a description of a Debian package.\n#[derive(Debug, Default, Clone)]\npub struct Stanza<'a> {\n #[allow(missing_docs)]\n pub package: &'a str,\n #[allow(missing_docs)]\n pub version: Version<'a>,\n #[allow(missing_docs)]\n pub architecture: &'a str,\n #[allow(missing_docs)]\n pub depends: Vec>,\n #[allow(missing_docs)]\n pub sha256: Option<&'a str>,\n #[allow(missing_docs)]\n pub size: Option,\n /// Path of the .deb file inside an index.\n pub file_name: Option<&'a str>,\n}\n\n/// A dependency, which is either a \"simple\" dependency, or a list of\n/// alternatives.\n#[derive(Debug, Clone)]\npub enum Dep<'a> {\n /// A simple dependency.\n Simple(SimpleDep<'a>),\n /// A dependency that can be supplied by multiple packages. This\n /// is an alternative mechanism to virtual packages.\n Alternatives {\n #[allow(missing_docs)]\n alt: Vec>,\n },\n}\n\n/// A single dependency.\n#[derive(Debug, Clone)]\npub struct SimpleDep<'a> {\n /// Name of the dependency.\n pub name: &'a str,\n /// Whether this dependency can have any version.\n pub any: bool,\n /// Constraints on dependencies.\n pub constraints: Vec<(&'a str, Version<'a>)>,\n}\n\nfn parse_control(s: &str) -> IResult<&str, Stanza> {\n let mut st = Stanza::default();\n\n for l in s.lines() {\n if l.is_empty() {\n let (_, b) = s.split_at(l.as_ptr() as usize - s.as_ptr() as usize);\n return Ok((b, st));\n }\n\n if let Some(i) = l.find(':') {\n let (key, val) = l.split_at(i);\n let (_, val) = val.split_at(1);\n debug!(\"key {:?} {:?}\", key, val);\n match key.trim() {\n \"Package\" => st.package = val.trim(),\n \"Version\" => st.version = parse_version(val.trim()).unwrap().1,\n \"Architecture\" => st.architecture = val.trim(),\n \"SHA256\" => st.sha256 = Some(val.trim()),\n \"Filename\" => st.file_name = Some(val.trim()),\n \"Depends\" | \"Pre-Depends\" => {\n let d = parse_deps(val.trim());\n debug!(\"{:?}\", d);\n if let Ok((\"\", a)) = d {\n st.depends = a\n } else {\n error!(\"error {:?}\", val.trim());\n return IResult::Err(nom::Err::Error(nom::error::make_error(\n s,\n nom::error::ErrorKind::Tag,\n )));\n }\n }\n _ => {}\n }\n }\n }\n\n Ok((\"\", st))\n}\n\n#[test]\nfn test_grub_common() {\n use tracing_subscriber::prelude::*;\n use tracing_subscriber::util::SubscriberInitExt;\n tracing_subscriber::registry()\n .with(\n tracing_subscriber::EnvFilter::try_from_default_env()\n .unwrap_or_else(|_| String::new().into()),\n )\n .with(tracing_subscriber::fmt::layer())\n .try_init()\n .unwrap();\n\n let (rest, p) = parse_control(\"Package: grub-common\\nArchitecture: amd64\\nVersion: 2.12-1ubuntu7\\nBuilt-Using: lzo2 (= 2.10-2build3)\\nMulti-Arch: foreign\\nPriority: optional\\nSection: admin\\nSource: grub2\\nOrigin: Ubuntu\\nMaintainer: Ubuntu Developers \\nOriginal-Maintainer: GRUB Maintainers \\nBugs: https://bugs.launchpad.net/ubuntu/+filebug\\nInstalled-Size: 12476\\nDepends: libc6 (>= 2.38), libdevmapper1.02.1 (>= 2:1.02.36), libefiboot1t64 (>=38), libefivar1t64 (>= 38), libfreetype6 (>= 2.2.1), libfuse3-3 (>= 3.2.3), liblzma5 (>= 5.1.1alpha+20120614), debconf (>= 0.5) | debconf-2.0, gettext-base, lsb-base (>= 3.0-6), python3, python3-apt\\nRecommends: os-prober (>= 1.33)\\nSuggests: multiboot-doc, grub-emu, mtools, xorriso (>= 0.5.6.pl00), desktop-base (>= 4.0.6), console-setup\\nConflicts: init-select\\nBreaks: apport (<< 2.1.1), friendly-recovery (<< 0.2.13), lupin-support (<< 0.55), mdadm (<< 2.6.7-2)\\nReplaces: grub-coreboot (<< 2.00-4), grub-efi (<< 1.99-1), grub-efi-amd64 (<< 2.00-4), grub-efi-ia32 (<< 2.00-4), grub-efi-ia64 (<< 2.00-4), grub-ieee1275 (<< 2.00-4), grub-linuxbios (<< 1.96+20080831-1), grub-pc (<< 2.00-4), grub-yeeloong (<< 2.00-4), init-select\\nFilename: pool/main/g/grub2/grub-common_2.12-1ubuntu7_amd64.deb\\nSize: 2119862\\nMD5sum: 86e63081ae4ee34d6a4f408ac6dbf0e4\\nSHA1: b98f9f88e5480423e041fd647b438ba2f6e6f5ea\\nSHA256: d8110b97b6fb6da40449c74b9cb527f02965dffaae8344399a711617f5a69249\\nSHA512: 85c63b8d3e6a870df48533ab525df13abe9ec4861ff4b5577def94f65a2ebf6ac44a54a6cd0eca1c825e1c7aa2bd14e4d4ed53f83d381963ac1dc51daa16482a\\nHomepage: https://www.gnu.org/software/grub/\\nDescription: GRand Unified Bootloader (common files)\\nTask: ubuntu-desktop-minimal, ubuntu-desktop, ubuntu-desktop-raspi, kubuntu-desktop, xubuntu-minimal, xubuntu-desktop, lubuntu-desktop, ubuntustudio-desktop-core, ubuntustudio-desktop, ubuntukylin-desktop,ubuntukylin-desktop-minimal, ubuntu-mate-core, ubuntu-mate-desktop, ubuntu-budgie-desktop-minimal, ubuntu-budgie-desktop, ubuntu-budgie-desktop-raspi, ubuntu-unity-desktop, edubuntu-desktop-gnome-minimal, edubuntu-desktop-gnome-raspi, ubuntucinnamon-desktop-minimal, ubuntucinnamon-desktop-raspi\\nDescription-md5: 9c75036dc0a0792fedbc58df208ed227\").unwrap();\n\n assert!(p.depends.iter().any(|x| match x {\n Dep::Simple(s) => s.name == \"liblzma5\",\n _ => false,\n }));\n\n assert!(rest.is_empty())\n}\n\n/// A version of a package.\n#[derive(Debug, Clone)]\npub struct Version<'a> {\n /// Epoch, i.e. a Debian mechanism to reorder upstream versions if\n /// necessary, for example if the upstream versioning scheme\n /// changes.\n pub epoch: u32,\n /// Upstream version.\n pub upstream_version: Upstream<'a>,\n /// Debian-specific suffix to distinguish between patches.\n pub debian: Option<&'a str>,\n}\n\nimpl<'a> Default for Version<'a> {\n fn default() -> Version<'a> {\n Version {\n epoch: 0,\n upstream_version: Upstream(\"\"),\n debian: None,\n }\n }\n}\n\nfn parse_constraint<'a>(s: &'a str) -> IResult<&'a str, (&'a str, Version<'a>)> {\n let (s, constraint) = tag(\"<<\")\n .or(tag(\"<=\"))\n .or(tag(\"=\"))\n .or(tag(\">=\"))\n .or(tag(\">>\"))\n .parse(s)?;\n debug!(\"parse_constraint {:?}\", constraint);\n let (s, _) = space0(s)?;\n let (s, version) = parse_version(s)?;\n debug!(\"parse_constraint {:?} {:?}\", s, (constraint, &version));\n Ok((s, (constraint, version)))\n}\n\nfn parse_dep<'a>(s0: &'a str) -> IResult<&'a str, Dep<'a>> {\n let (s, name) = parse_name(s0)?;\n let (s, any) = if s.starts_with(\":any\") {\n let (_, b) = s.split_at(4);\n (b, true)\n } else {\n (s, false)\n };\n let (s, _) = space0(s)?;\n let mut constraints = Vec::new();\n if let Ok((s, _)) = tag::<_, _, ()>(\"(\").parse(s) {\n let (s, version) = if let Some(i) = s.find(')') {\n let (a, b) = s.split_at(i);\n let (_, b) = b.split_at(1);\n (b, a)\n } else {\n return IResult::Err(nom::Err::Error(nom::error::make_error(\n s,\n nom::error::ErrorKind::Tag,\n )));\n };\n\n let mut v = version;\n while let Ok((v_, c)) = parse_constraint(v) {\n constraints.push(c);\n let (v_, _) = space0(v_)?;\n if let Ok((v_, _)) = tag::<_, _, ()>(\",\").parse(v_) {\n let (v_, _) = space0(v_)?;\n v = v_;\n } else {\n break;\n }\n }\n\n Ok((\n s,\n Dep::Simple(SimpleDep {\n name,\n any,\n constraints,\n }),\n ))\n } else {\n Ok((\n s,\n Dep::Simple(SimpleDep {\n name,\n any,\n constraints,\n }),\n ))\n }\n}\n\nfn parse_name(s: &str) -> IResult<&str, &str> {\n if let Some(i) = s.find(|c| {\n !((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '.' || c == '+' || c == '-')\n }) {\n if i > 0 {\n let (a, b) = s.split_at(i);\n return Ok((b, a));\n }\n } else {\n return Ok((\"\", s));\n }\n error!(\"ERROR {:?}\", s);\n return IResult::Err(nom::Err::Error(nom::error::make_error(\n s,\n nom::error::ErrorKind::Tag,\n )));\n}\n\nfn parse_deps<'a>(s: &'a str) -> IResult<&'a str, Vec>> {\n let mut d = Vec::new();\n let (mut s, _) = space0(s)?;\n let mut alt_is_open = false;\n while let Ok((s_, d_)) = parse_dep(s) {\n let (s_, _) = space0(s_)?;\n if let Ok((s_, _)) = tag::<_, _, ()>(\"|\").parse(s_) {\n let (s_, _) = space0(s_)?;\n s = s_;\n alt_is_open = true;\n if let Dep::Simple(d_) = d_ {\n if let Some(Dep::Alternatives { ref mut alt }) = d.last_mut() {\n alt.push(d_)\n } else {\n d.push(Dep::Alternatives { alt: vec![d_] })\n }\n } else {\n panic!(\"{:?}\", s);\n }\n } else if let Ok((s_, _)) = tag::<_, _, ()>(\",\").parse(s_) {\n if alt_is_open {\n if let Some(Dep::Alternatives { ref mut alt }) = d.last_mut() {\n if let Dep::Simple(d_) = d_ {\n alt.push(d_)\n } else {\n panic!(\"{:?}\", s);\n }\n }\n } else {\n d.push(d_)\n }\n alt_is_open = false;\n s = s_;\n } else {\n if alt_is_open {\n if let Some(Dep::Alternatives { ref mut alt }) = d.last_mut() {\n if let Dep::Simple(d_) = d_ {\n alt.push(d_)\n } else {\n panic!(\"{:?}\", s);\n }\n }\n } else {\n d.push(d_)\n }\n s = s_;\n break;\n }\n let (s_, _) = space0(s)?;\n s = s_;\n }\n Ok((s, d))\n}\n\n/// The representation of an upstream version. Will implement `Ord`.\n#[derive(Debug, Clone, PartialEq, Eq)]\npub struct Upstream<'a>(&'a str);\n\nimpl<'a> std::ops::Deref for Upstream<'a> {\n type Target = str;\n fn deref(&self) -> &str {\n self.0\n }\n}\n\nimpl<'a> PartialOrd for Upstream<'a> {\n /// Following the algorithm described here:\n /// https://www.debian.org/doc/debian-policy/ch-controlfields.html#version\n fn partial_cmp(&self, b: &Upstream<'a>) -> Option {\n fn split_initial(s: &str) -> (&str, &str, &str) {\n // Find `u`, the first digit, and `v > u`, the first non-digit after `u`.\n let mut u = s.len();\n let mut v = s.len();\n for (n, &b) in s.as_bytes().iter().enumerate() {\n if u == s.len() {\n if b >= b'0' && b <= b'9' {\n u = n\n }\n } else if b < b'0' || b > b'9' {\n v = n;\n break;\n }\n }\n let (ab, c) = s.split_at(v);\n let (a, b) = ab.split_at(u);\n (a, b, c)\n }\n let mut a = self.0;\n let mut b = b.0;\n use std::cmp::Ordering;\n loop {\n let (a0, a1, a_) = split_initial(a);\n let (b0, b1, b_) = split_initial(b);\n // Compare a0 / b0 using the modified ASCII ordering described in the Debian manual.\n let mut a0i = a0.as_bytes().iter();\n let mut b0i = b0.as_bytes().iter();\n loop {\n match (a0i.next(), b0i.next()) {\n (None, None) => break,\n (Some(c), Some(d)) if c == d => continue,\n (Some(b'~'), _) => return Some(Ordering::Less),\n (_, Some(b'~')) => return Some(Ordering::Greater),\n (Some(c), Some(d)) if c.is_ascii_alphabetic() && !d.is_ascii_alphabetic() => {\n return Some(Ordering::Less);\n }\n (Some(c), Some(d)) if d.is_ascii_alphabetic() && !c.is_ascii_alphabetic() => {\n return Some(Ordering::Greater);\n }\n (c, d) => return Some(c.cmp(&d)),\n }\n }\n // If we haven't returned, a0 == b0. Compare the digits part.\n let a1 = if a1.is_empty() {\n 0\n } else {\n a1.parse::().unwrap()\n };\n let b1 = if b1.is_empty() {\n 0\n } else {\n b1.parse::().unwrap()\n };\n let cmp1 = a1.cmp(&b1);\n if let Ordering::Equal = cmp1 {\n a = a_;\n b = b_;\n } else {\n return Some(cmp1);\n }\n }\n }\n}\n\nimpl<'a> Ord for Upstream<'a> {\n fn cmp(&self, b: &Upstream<'a>) -> std::cmp::Ordering {\n self.partial_cmp(b).unwrap()\n }\n}\n\n#[test]\nfn test_upstream_ordering() {\n let mut x = [\n Upstream(\"~~\"),\n Upstream(\"~~a\"),\n Upstream(\"~\"),\n Upstream(\"\"),\n Upstream(\"a\"),\n ];\n let y = x.clone();\n x.sort();\n assert_eq!(x, y,);\n}\n\nuse nom::{\n bytes::tag,\n character::complete::{digit1, newline, space0},\n multi::separated_list1,\n IResult, Parser,\n};\n\n/// Parse a version in the Debian version format.\nfn parse_version<'a>(s: &'a str) -> IResult<&'a str, Version<'a>> {\n fn epoch(s: &str) -> IResult<&str, u32> {\n let (s, i) = digit1(s)?;\n let (s, _) = tag(\":\").parse(s)?;\n Ok((s, i.parse().unwrap()))\n }\n\n let (s, epoch) = epoch(s).unwrap_or((s, 0));\n lazy_static! {\n static ref RE_DASH: regex::Regex =\n regex::Regex::new(r\"^[a-z0-9\\.~+-]+-([a-z0-9\\.~+]+)\").unwrap();\n static ref RE: regex::Regex = regex::Regex::new(r\"^[a-z0-9\\.~+]+\").unwrap();\n }\n\n let (s, v) = if let Some(m) = RE_DASH.find(s) {\n debug!(\"parse_version RE_DASH {:?}\", s);\n let (a, b) = s.split_at(m.end());\n (b, a)\n } else if let Some(m) = RE.find(s) {\n debug!(\"parse_version RE {:?}\", s);\n let (a, b) = s.split_at(m.end());\n (b, a)\n } else {\n debug!(\"parse_version failed {:?}\", s);\n return IResult::Err(nom::Err::Error(nom::error::make_error(\n s,\n nom::error::ErrorKind::Tag,\n )));\n };\n\n let (upstream_version, debian) = if let Some(i) = v.rfind('-') {\n let (a, b) = v.split_at(i);\n (Upstream(a), Some(b.split_at(1).1))\n } else {\n (Upstream(v), None)\n };\n\n Ok((\n s,\n Version {\n epoch,\n upstream_version,\n debian,\n },\n ))\n}\n\n/// Structure of the \"headers\" in the debian file. No alignment\n/// necessary, the numbers are in decimal. No heap allocation.\n#[derive(Debug)]\n#[repr(C)]\nstruct H {\n file_id: [u8; 16],\n timestamp: [u8; 12],\n owner_id: [u8; 6],\n group_id: [u8; 6],\n file_mode: [u8; 8],\n file_size: [u8; 10],\n end_char: [u8; 2],\n}\n\n/// Parsed version of `H`, still no heap allocation.\n#[allow(dead_code)]\n#[derive(Debug)]\nstruct Header {\n file_id: [u8; 16],\n timestamp: u64,\n owner_id: u32,\n group_id: u32,\n file_mode: u32,\n file_size: u64,\n}\n\n#[allow(missing_docs)]\n/// Possible errors for .deb files.\n#[derive(Debug, Error)]\npub enum Error {\n #[error(\"Deb file parse error\")]\n ParseError,\n #[error(transparent)]\n Utf8(#[from] std::str::Utf8Error),\n #[error(transparent)]\n Int(#[from] std::num::ParseIntError),\n #[error(transparent)]\n IO(#[from] std::io::Error),\n #[error(\"Unsupported compression algorithm: {file_id}\")]\n UnsupportedCompression { file_id: String },\n #[error(\"Version parse: {version}\")]\n Version { version: String },\n}\n\nimpl Header {\n pub fn file_id(&self) -> &str {\n std::str::from_utf8(&self.file_id).unwrap().trim()\n }\n}\n\nimpl H {\n fn parse(&self) -> Result {\n std::str::from_utf8(&self.file_id)?;\n Ok(Header {\n file_id: self.file_id,\n timestamp: std::str::from_utf8(&self.timestamp)?.trim().parse()?,\n owner_id: std::str::from_utf8(&self.owner_id)?.trim().parse()?,\n group_id: std::str::from_utf8(&self.group_id)?.trim().parse().unwrap(),\n file_mode: u32::from_str_radix(std::str::from_utf8(&self.file_mode)?.trim(), 8)?,\n file_size: std::str::from_utf8(&self.file_size)?.trim().parse()?,\n })\n }\n}\n\nfn read_hdr(r: &mut R) -> Result {\n unsafe {\n assert_eq!(size_of::(), HEADER_SIZE as usize);\n let mut b: H = std::mem::zeroed();\n let pb: *mut H = &mut b;\n r.read_exact(&mut std::slice::from_raw_parts_mut(\n pb as *mut u8,\n size_of::(),\n ))?;\n debug!(\"{:?}\", b);\n b.parse()\n }\n}\n\nconst HEADER_SIZE: u64 = 60;\n\nimpl Deb {\n /// Parse the control part, containing the description (stanza) of this package.\n pub fn parse_control(&self) -> Vec {\n if let Ok((\"\", st)) = separated_list1(newline, parse_control).parse(&self.control_file) {\n st\n } else {\n Vec::new()\n }\n }\n\n /// Return the md5sums of each file.\n pub fn md5sums(&self) -> &HashMap {\n &self.md5sums\n }\n\n /// Decompress the data part of the deb file into a directory.\n pub fn decompress>(\n &self,\n mut r: R,\n path: P,\n ) -> Result<(), Error> {\n r.seek(SeekFrom::Start(self.data_offset))?;\n debug!(\"decompress {:?}\", self.data.file_id());\n if self.data.file_id().ends_with(\".tar.gz\") {\n unimplemented!()\n } else if self.data.file_id().ends_with(\".tar.zst\") {\n let mut ar = tar::Archive::new(\n zstd::stream::read::Decoder::new(r.take(self.data.file_size)).unwrap(),\n );\n for e in ar.entries().unwrap() {\n let mut e = e.unwrap();\n debug!(\"zstd decompress {:?}\", e.path());\n // f(&e.path()?);\n e.unpack_in(&path).unwrap();\n }\n } else if self.data.file_id().ends_with(\".tar.xz\") {\n let mut ar = tar::Archive::new(xz::read::XzDecoder::new(r.take(self.data.file_size)));\n for e in ar.entries().unwrap() {\n let mut e = e.unwrap();\n debug!(\"xz decompress {:?}\", e.path());\n // f(&e.path()?);\n e.unpack_in(&path).unwrap();\n }\n } else if self.data.file_id().ends_with(\".tar\") {\n let mut ar = tar::Archive::new(r.take(self.data.file_size));\n for e in ar.entries().unwrap() {\n let mut e = e.unwrap();\n debug!(\"tar extract {:?}\", e.path());\n // f(&e.path()?);\n e.unpack_in(&path).unwrap();\n }\n } else {\n unimplemented!()\n };\n Ok(())\n }\n\n /// Parse a `.deb` file from a buffered reader.\n pub fn read(mut r: R) -> Result {\n let mut b = [0; 8];\n r.read_exact(&mut b)?;\n if &b != b\"!\\n\" {\n return Err(Error::ParseError);\n }\n\n let global = read_hdr(&mut r)?;\n trace!(\"GLOBAL {:?}\", global);\n assert_eq!(global.file_size, 4);\n r.seek(SeekFrom::Current(global.file_size as i64))?;\n\n // r.skip_until(b'c')?; // 'control.…'\n // r.seek(SeekFrom::Current(-1))?;\n let control = read_hdr(&mut r)?;\n trace!(\"CONTROL {:?}\", control);\n\n // Control files are expected to be short, decompress.\n let mut ctrl = vec![0; control.file_size as usize];\n r.read_exact(&mut ctrl)?;\n\n // gzip xz zstd none\n let ctrl_tar = if control.file_id().ends_with(\".tar.gz\") {\n unimplemented!()\n } else if control.file_id().ends_with(\".tar.zst\") {\n zstd::decode_all(&ctrl[..])?\n } else if control.file_id().ends_with(\".tar.xz\") {\n let mut decompressor = xz::read::XzDecoder::new(&ctrl[..]);\n let mut result = Vec::new();\n decompressor.read_to_end(&mut result)?;\n result\n } else if control.file_id().ends_with(\".tar\") {\n ctrl\n } else {\n return Err(Error::UnsupportedCompression {\n file_id: control.file_id().to_string(),\n });\n };\n let mut ctrl_tar = tar::Archive::new(&ctrl_tar[..]);\n\n let mut control_file = String::new();\n let mut md5sums = HashMap::new();\n for e in ctrl_tar.entries().unwrap() {\n let mut e = e.unwrap();\n if e.path()?.file_name() == Some(OsStr::new(\"control\")) {\n e.read_to_string(&mut control_file)?;\n } else if e.path()?.file_name() == Some(OsStr::new(\"md5sums\")) {\n let mut e = BufReader::new(e);\n let mut s = String::new();\n while e.read_line(&mut s)? > 0 {\n let mut it = s.split(' ').filter(|x| !x.is_empty());\n if let (Some(hash), Some(file)) = (it.next(), it.next()) {\n md5sums.insert(file.trim().to_string(), hash.trim().to_string());\n }\n s.clear();\n }\n }\n }\n\n if control.file_size % 2 == 1 {\n r.seek(SeekFrom::Current(1))?;\n }\n let data = read_hdr(&mut r)?;\n debug!(\"data = {:?}\", data);\n\n Ok(Deb {\n md5sums,\n _global: global,\n _control: control,\n control_file,\n data,\n data_offset: r.seek(SeekFrom::Current(0))?,\n })\n }\n}\n"}]}},{"FileDel":{"deleted_names":[{"basename":"lib.rs~","metadata":0}],"del":{"EdgeMap":{"edges":[{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":2,"pos":15},"to":{"change":3,"start":22535,"end":22566},"introduced_by":3},{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":3,"pos":22566},"to":{"change":3,"start":22567,"end":22567},"introduced_by":3}],"inode":{"change":3,"pos":22567}}},"content_edges":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":3,"pos":22567},"to":{"change":3,"start":22568,"end":44501},"introduced_by":3}],"inode":{"change":3,"pos":22567}},"content":[{"Del":"//! Run bash scripts in containers on Linux, with only deterministic\n//! Debian or Ubuntu packages in scope.\n#![deny(\n missing_docs,\n trivial_casts,\n trivial_numeric_casts,\n unused_import_braces,\n unused_qualifications\n)]\nuse futures::SinkExt;\nuse futures::StreamExt;\nuse std::collections::HashMap;\nuse std::path::PathBuf;\nuse std::sync::Arc;\nuse tempfile::NamedTempFile;\nuse thiserror::*;\nuse tokio::sync::{Mutex, Semaphore};\nuse tracing::*;\n\n/// Handle Debian packages.\npub mod deb;\n\n/// Extract a Debian package and all dependencies into the store.\npub mod extract;\n\n/// Recursive iterator on the files/directories in a path.\npub mod find_files;\n\n/// Mount and unmount paths.\npub mod mount;\n\n/// Run scripts in a chroot inside a new Linux namespace, with the\n/// right directories mounted and symbolically linked to simulate a\n/// Debian/Ubuntu filesystem hierarchy.\npub mod container;\n\nmod dummy_sink;\nuse dummy_sink::*;\n\n/// Errors\n#[derive(Debug, Error)]\npub enum Error {\n /// An error from manipulating a Debian package.\n #[error(transparent)]\n Deb(#[from] deb::Error),\n /// IO error\n #[error(transparent)]\n IO(#[from] std::io::Error),\n /// An error from persisting a temporary file.\n #[error(transparent)]\n Persist(#[from] tempfile::PersistError),\n /// An error from creating a temporary file.\n #[error(transparent)]\n Tempfile(#[from] async_tempfile::Error),\n #[error(transparent)]\n /// An error from `elfedit`, this crate's companion ELF patcher.\n Elf(#[from] elfedit::Error),\n /// HTTP errors\n #[error(transparent)]\n Reqwest(#[from] reqwest::Error),\n /// Wrong signature (on an Ubuntu index)\n #[error(\"Signature error\")]\n Signature,\n /// Wrong package hash\n #[error(\"Hash: expected {expected}, got {got}.\")]\n WrongHash {\n /// Expected hash.\n expected: String,\n /// Obtained hash.\n got: String,\n },\n /// Wrong package or file size\n #[error(\"Wrong size\")]\n WrongSize,\n /// Wrong result symlink: Elpe packages have one \"input name\"\n /// given by the hash of their inputs, and that directory is\n /// symlinked from the \"output name\", which is the hash of their\n /// output. This makes the outputs verifiable all the way down:\n /// failures to verify result in this error.\n #[error(\"Wrong result symlink, expected {expected:?}, got {got:?}\")]\n WrongResultSymlink {\n /// Expected output.\n expected: PathBuf,\n /// Obtained output.\n got: PathBuf,\n },\n /// The build process returned a status other than 0.\n #[error(\"Build process returned {status}\")]\n BuildReturn {\n /// Return status.\n status: i32,\n },\n /// Package not found\n #[error(\"Package not found: {pkg}\")]\n PackageNotFound {\n /// The package name.\n pkg: String,\n },\n}\n\n/// A Debian index client.\n#[derive(Clone)]\npub struct Client {\n c: lazy_init::Lazy,\n pgp_home: PathBuf,\n mirror: String,\n store_path: PathBuf,\n in_release: Arc, Arc>>>,\n download_sem: Arc,\n store_locks: Arc>>>>,\n timeout: std::time::Duration,\n}\n\n/// Hashes, used for example in URL downloads.\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub enum Hash {\n #[allow(missing_docs)]\n Blake3([u8; 32]),\n #[allow(missing_docs)]\n Sha256([u8; 32]),\n #[allow(missing_docs)]\n Sha512([u8; 64]),\n}\n\n/// Hasher for each different hash algorithm.\npub enum Hasher {\n #[allow(missing_docs)]\n Blake3(blake3::Hasher),\n #[allow(missing_docs)]\n Sha256(sha2::Sha256),\n #[allow(missing_docs)]\n Sha512(sha2::Sha512),\n}\n\nimpl Hash {\n /// Create a hasher for this hash algorithm.\n pub fn hasher(&self) -> Hasher {\n match self {\n Hash::Blake3(_) => Hasher::Blake3(blake3::Hasher::new()),\n Hash::Sha256(_) => Hasher::Sha256(sha2::Sha256::new()),\n Hash::Sha512(_) => Hasher::Sha512(sha2::Sha512::new()),\n }\n }\n}\n\nimpl Hasher {\n /// Update the hasher with new bytes.\n pub fn update(&mut self, b: &[u8]) {\n match self {\n Hasher::Blake3(h) => {\n h.update(b);\n }\n Hasher::Sha256(h) => {\n h.update(b);\n }\n Hasher::Sha512(h) => {\n h.update(b);\n }\n }\n }\n\n /// Create the hash, to be compared with the one supplied by the user.\n pub fn finalize(self) -> Hash {\n match self {\n Hasher::Blake3(h) => Hash::Blake3(h.finalize().into()),\n Hasher::Sha256(h) => Hash::Sha256(h.finalize().into()),\n Hasher::Sha512(h) => Hash::Sha512(h.finalize().into()),\n }\n }\n}\n\nimpl std::ops::Deref for Hash {\n type Target = [u8];\n fn deref(&self) -> &Self::Target {\n match self {\n Hash::Blake3(h) => &h[..],\n Hash::Sha256(h) => &h[..],\n Hash::Sha512(h) => &h[..],\n }\n }\n}\n\nimpl std::ops::DerefMut for Hash {\n fn deref_mut(&mut self) -> &mut Self::Target {\n match self {\n Hash::Blake3(h) => &mut h[..],\n Hash::Sha256(h) => &mut h[..],\n Hash::Sha512(h) => &mut h[..],\n }\n }\n}\n\nimpl Client {\n /// Download a URL.\n pub async fn http_download(&self, url: &str, h: Hash) -> Result {\n let expected_path = self\n .store_path\n .join(data_encoding::BASE32_DNSSEC.encode(&h));\n\n if let Ok(mut f) = tokio::fs::File::open(&expected_path).await {\n use tokio::io::AsyncReadExt;\n let mut buf = [0; 4096];\n let mut hasher = h.hasher();\n while let Ok(n) = f.read(&mut buf).await {\n if n == 0 {\n break;\n }\n hasher.update(&buf[..n]);\n }\n let got = hasher.finalize();\n return if got == h {\n Ok(expected_path)\n } else {\n Err(Error::WrongHash {\n expected: data_encoding::HEXLOWER.encode(&h),\n got: data_encoding::HEXLOWER.encode(&got),\n })\n };\n }\n\n let mut r = self.client().get(url).send().await?;\n let mut t: Option>> =\n None;\n\n let file = NamedTempFile::new_in(&self.store_path)?;\n let mut f = Some(tokio::fs::File::create(&file).await?);\n let mut hasher = h.hasher();\n while let Some(chunk) = r.chunk().await? {\n hasher.update(&chunk);\n\n if let Some(t) = t.take() {\n f = Some(t.await.unwrap().unwrap())\n }\n let mut f = f.take().unwrap();\n t = Some(tokio::spawn(async move {\n f.write_all(&chunk).await?;\n Ok(f)\n }))\n }\n let got = hasher.finalize();\n if got == h {\n file.persist(&expected_path)?;\n Ok(expected_path)\n } else {\n Err(Error::WrongHash {\n expected: data_encoding::HEXLOWER.encode(&h),\n got: data_encoding::HEXLOWER.encode(&got),\n })\n }\n }\n}\n\n/// A locked store path, to prevent concurrent writes to the\n/// store. For performance reasons, these are memory locks rather than\n/// filesystem locks.\npub struct StoreLock {\n locks: Arc>>>>,\n p: PathBuf,\n _lock: tokio::sync::OwnedMutexGuard<()>,\n}\n\nimpl Drop for StoreLock {\n fn drop(&mut self) {\n debug!(\"store lock: dropping {:?}\", self.p);\n self.locks.lock().unwrap().remove(&self.p);\n }\n}\n\n#[derive(Debug)]\nstruct Downloaded {\n path: PathBuf,\n}\n\nuse sha2::Digest;\nuse std::process::Stdio;\nuse tokio::io::{AsyncBufReadExt, AsyncWriteExt};\nuse tokio::process::Command;\n\n/// Root file of a package index, containing the signed hashes of the package list.\n#[derive(Debug)]\npub struct InRelease {\n hashed: HashMap,\n release: std::borrow::Cow<'static, str>,\n}\n\nstruct HashedWriter {\n hasher: sha2::Sha256,\n w: W,\n}\n\nimpl std::io::Write for HashedWriter {\n fn write(&mut self, b: &[u8]) -> Result {\n self.hasher.update(b);\n self.w.write_all(b).unwrap();\n Ok(b.len())\n }\n fn flush(&mut self) -> Result<(), std::io::Error> {\n self.w.flush()\n }\n}\n\nconst MAX_PARALLEL_DOWNLOADS: usize = 20;\n\nimpl Client {\n /// Create a client.\n pub fn new, Q: AsRef>(\n pgp_home: P,\n store_path: Q,\n mirror: &str,\n ) -> Self {\n std::fs::create_dir_all(store_path.as_ref()).unwrap();\n Client {\n c: lazy_init::Lazy::new(),\n mirror: mirror.to_string(),\n store_path: store_path.as_ref().to_path_buf(),\n in_release: Arc::new(HashMap::new().into()),\n download_sem: Arc::new(Semaphore::new(MAX_PARALLEL_DOWNLOADS)),\n store_locks: Arc::new(std::sync::Mutex::new(HashMap::new())),\n timeout: std::time::Duration::from_secs(30),\n pgp_home: pgp_home.as_ref().to_path_buf(),\n }\n }\n\n /// Retrieve the store path this client was created with.\n pub fn store_path(&self) -> &std::path::Path {\n &self.store_path\n }\n\n fn client(&self) -> &reqwest::Client {\n self.c.get_or_create(|| {\n reqwest::ClientBuilder::new()\n .read_timeout(self.timeout)\n .build()\n .unwrap()\n })\n }\n\n /// Like `tokio::process::Command::new`, but where `cmd` is taken\n /// from inside the supplied package. This decompresses the\n /// package.\n pub async fn command>, P: AsRef>(\n &self,\n release: R,\n pkg: &str,\n cmd: P,\n ) -> Command {\n let h = self.in_release(release.into()).await.unwrap();\n let arch = if cfg!(target_arch = \"x86_64\") {\n \"amd64\"\n } else if cfg!(target_arch = \"aarch64\") {\n \"aarch64\"\n } else {\n unreachable!()\n };\n let (main, universe) = tokio::join!(\n self.packages(&h, \"main\", arch),\n self.packages(&h, \"universe\", arch)\n );\n let main = main.unwrap();\n let universe = universe.unwrap();\n\n let index = vec![\n deb::Index::open(&main).unwrap(),\n deb::Index::open(&universe).unwrap(),\n ];\n let p = extract::download_extract_deps(&index, self, pkg, &[], DummySink {})\n .await\n .unwrap();\n debug!(\"running {:?}\", p.result.last().unwrap().join(&cmd));\n Command::new(p.result.last().unwrap().join(&cmd))\n }\n\n /// This locks a store path in order to avoid races to write to\n /// the same store path.\n ///\n /// For performance and portability reasons, this is implemented\n /// using in-memory Mutexes rather than using filesystem\n /// locks. This process is the only one allowed to write to the\n /// store anyway.\n pub async fn lock_store_path>(&self, path: P) -> StoreLock {\n debug!(\"locking store path {:?}\", path.as_ref());\n let p = path.as_ref().to_path_buf();\n let mutex = {\n let mut locks = self.store_locks.lock().unwrap();\n locks\n .entry(p.clone())\n .or_insert_with(|| Arc::new(Mutex::new(())))\n .clone()\n };\n let lock = mutex.lock_owned().await;\n debug!(\"lock acquired: {:?}\", p);\n StoreLock {\n locks: self.store_locks.clone(),\n p,\n _lock: lock,\n }\n }\n\n /// Download a list of packages.\n pub async fn packages(\n &self,\n in_release: &InRelease,\n component: &str,\n arch: &str,\n ) -> Result {\n let end = format!(\"{component}/binary-{arch}/Packages\");\n let end_xz = format!(\"{component}/binary-{arch}/Packages.xz\");\n\n let (size_xz, expected_hash_xz) = in_release.hashed.get(&end_xz).expect(&format!(\"{} not found in InRelease\", end_xz));\n let (size, expected_hash) = in_release.hashed.get(&end).expect(&format!(\"{} not found in InRelease\", &end));\n\n let expected_xz = data_encoding::BASE32_DNSSEC.encode(&*expected_hash_xz);\n let expected = data_encoding::BASE32_DNSSEC.encode(&*expected_hash);\n\n std::fs::create_dir_all(&self.store_path)?;\n let expected_path = self.store_path.join(&expected);\n\n\t\n if let Ok(_) = std::fs::metadata(&expected_path) {\n return Ok(expected_path);\n }\n\n let ref m = self.mirror;\n let ref release = in_release.release;\n let r = {\n let client = self.client();\n let permit = self.download_sem.acquire().await.unwrap();\n let r = client\n .get(&format!(\n \"{m}/dists/{release}/{component}/binary-{arch}/Packages.xz\"\n ))\n .send()\n .await?;\n drop(permit);\n r\n };\n\t\n let file_xz = NamedTempFile::new_in(&self.store_path)?;\n let file = NamedTempFile::new_in(&self.store_path)?;\n let mut xz_dec = xz2::write::XzDecoder::new(HashedWriter {\n w: std::fs::File::create(&file)?,\n hasher: sha2::Sha256::new(),\n });\n\n let mut f = tokio::fs::File::create(&file_xz).await?;\n let mut r = r.bytes_stream();\n let mut hasher_xz = sha2::Sha256::new();\n\t\n\n\twarn!(\"{:?}\", expected_hash_xz);\n\t\n let mut total = 0;\n while let Some(item) = r.next().await {\n let item = item?;\n total += item.len();\n {\n // we can't use write_all here, since lzma has padding\n // at the end of the file and the xz2 crate rejects\n // the padding.\n use std::io::Write;\n let mut i = 0;\n loop {\n\t\t warn!(\"{:?}\", &item[i..]);\n let n = xz_dec.write(&item[i..]);\n\t\t warn!(\"{:?}\", n);\n\t\t let n = n?;\n if n == 0 {\n break;\n } else {\n i += n\n }\n }\n }\n hasher_xz.update(&item);\n f.write_all(&item).await?;\n }\n if total != *size_xz || xz_dec.total_out() != *size as u64 {\n return Err(Error::WrongSize);\n }\n let w = xz_dec.finish().unwrap();\n let got_xz = &hasher_xz.finalize()[..];\n let got = &w.hasher.finalize()[..];\n\n\t\n\twarn!(\"haha: {:?}\", expected_hash_xz);\n\t\n\t \n if got_xz == expected_hash_xz && got == expected_hash {\n let mut expected_path_xz = self.store_path.join(&expected_xz);\n expected_path_xz.set_extension(\"xz\");\n\n file_xz.persist(&expected_path_xz)?;\n file.persist(&expected_path)?;\n Ok(expected_path)\n } else {\n Err(Error::WrongHash {\n expected: expected_xz,\n got: data_encoding::HEXLOWER.encode(&got),\n })\n }\n }\n\n /// Download the \"InRelease\" file of the index, and verify the signatures.\n pub async fn in_release>>(\n &self,\n release: R,\n ) -> Result, Error> {\n\n\tlet ref m = self.mirror;\n let release = release.into();\n debug!(\"downloading in_release {:?}\", release);\n let mut ubuntu = self.store_path.join(\"ubuntu\");\n std::fs::create_dir_all(&ubuntu)?;\n ubuntu.push(&*release);\n\n let mut lock = self.in_release.lock().await;\n if let Some(l) = (&*lock).get(&release) {\n debug!(\"in_release: lock\");\n return Ok(l.clone());\n }\n\n debug!(\"open {:?}\", ubuntu);\n let f = tokio::fs::File::open(&ubuntu).await;\n if let Ok(f) = f {\n let r = Arc::new(self.read_in_release(release.clone(), f).await?);\n lock.insert(release.clone(), r.clone());\n Ok(r)\n } else {\n debug!(\"downloading InRelease to {:?}\", ubuntu);\n let store_lock = self.lock_store_path(&ubuntu).await;\n let r = self\n .client()\n .get(&format!(\"{m}/dists/{release}/InRelease\"))\n .send()\n .await?;\n\n let tmp = async_tempfile::TempFile::new_in(ubuntu.parent().unwrap()).await?;\n\n // Sequoia wants to extract the verification code from\n // their binary and make it available as a lib, but\n // haven't done so as of June 2025.\n let mut com = Command::new(\"sq\")\n .env(\"HOME\", &self.pgp_home)\n .arg(\"verify\")\n .arg(\"--overwrite\")\n .arg(&format!(\"--output={}\", tmp.file_path().to_str().unwrap()))\n .arg(\"--message\")\n .stdin(Stdio::piped())\n .spawn()?;\n let mut i = com.stdin.take().unwrap();\n let mut r = r.bytes_stream();\n\n // Here we know `sq` doesn't start writing until consuming all\n // its stdin.\n while let Some(item) = r.next().await {\n i.write_all(&item?).await?;\n }\n drop(i);\n let status = com.wait().await?;\n let result = if status.success() {\n self.read_in_release(\n release.clone(),\n tokio::fs::File::open(&tmp.file_path()).await?,\n )\n .await\n } else {\n Err(Error::Signature)\n };\n let r = Arc::new(result?);\n lock.insert(release, r.clone());\n drop(store_lock);\n\n tokio::fs::rename(&tmp.file_path(), &ubuntu).await?;\n std::mem::forget(tmp);\n\n Ok(r)\n }\n }\n\n /// Read an already downloaded InRelease file, without re-checking\n /// the signatures.\n pub async fn read_in_release(\n &self,\n release: std::borrow::Cow<'static, str>,\n o: R,\n ) -> Result {\n let mut b = tokio::io::BufReader::new(o).lines();\n let mut result = HashMap::new();\n let mut recording = false;\n while let Some(l) = b.next_line().await? {\n if recording && l.starts_with(\" \") {\n let mut s = l.split(' ').filter(|x| !x.is_empty());\n let hash = s.next().unwrap();\n let mut hash_ = [0; 32];\n data_encoding::HEXLOWER_PERMISSIVE\n .decode_mut(hash.as_bytes(), &mut hash_)\n .unwrap();\n let size = s.next().unwrap();\n let name = s.next().unwrap();\n result.insert(name.to_string(), (size.parse().unwrap(), hash_));\n } else {\n recording = l == \"SHA256:\";\n }\n }\n\n Ok(InRelease {\n release,\n hashed: result,\n })\n }\n\n fn url(&self, file_name: Option<&str>) -> String {\n let ref m = self.mirror;\n let filename = file_name.unwrap();\n format!(\"{m}/{filename}\")\n }\n\n /// Download the given URL and check the hash, moving the\n /// resulting dir atomically.\n async fn download_url<'a, S: futures::Sink + Unpin>(\n &self,\n url: &str,\n sha256: &str,\n mut tx: S,\n ) -> Result<(Downloaded, bool), Error>\n where\n S::Error: std::fmt::Debug,\n {\n let base = url.split('/').last().unwrap();\n let path = self.store_path.join(&format!(\"{}-{}\", sha256, base));\n if tokio::fs::metadata(&path).await.is_ok() {\n debug!(\"is_ok {:?}\", path);\n return Ok((Downloaded { path }, false));\n }\n\n let lock = self.lock_store_path(path.clone()).await;\n tx.send(extract::Msg::Downloading(url.to_string()))\n .await\n .unwrap();\n\n info!(\"download url {:?} {:?}\", url, sha256);\n const MAX_ATTEMPTS: usize = 10;\n for i in 1..=MAX_ATTEMPTS {\n match self.try_download(url, sha256, &path).await {\n Ok(()) => break,\n Err(e) if i == MAX_ATTEMPTS => return Err(e),\n Err(e) => {\n error!(\"attempt {:?} at downloading {:?}: {:?}\", i, url, e);\n tokio::time::sleep(std::time::Duration::from_secs(1)).await;\n }\n }\n }\n drop(lock); // Ensure lock lives until here.\n Ok((Downloaded { path }, true))\n }\n\n async fn try_download(\n &self,\n url: &str,\n sha256: &str,\n path: &std::path::Path,\n ) -> Result<(), Error> {\n let r = self.client().get(url).send().await?;\n\n let mut s = r.bytes_stream();\n tokio::fs::create_dir_all(&self.store_path).await?;\n let mut hasher = sha2::Sha256::new();\n\n let mut f = async_tempfile::TempFile::new_in(self.store_path.as_path()).await?;\n while let Some(item) = s.next().await {\n let item = item?;\n hasher.update(&item);\n f.write_all(&item).await?;\n }\n f.flush().await?;\n let hash = data_encoding::HEXLOWER_PERMISSIVE.encode(&hasher.finalize());\n if &hash != sha256 {\n return Err(Error::WrongHash {\n expected: sha256.to_string(),\n got: hash,\n });\n }\n tokio::fs::rename(&f.file_path(), &path).await?;\n std::mem::forget(f);\n Ok(())\n }\n}\n"}]}},{"FileDel":{"deleted_names":[{"basename":"main.rs~","metadata":0}],"del":{"EdgeMap":{"edges":[{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":2,"pos":15},"to":{"change":3,"start":44502,"end":44534},"introduced_by":3},{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":3,"pos":44534},"to":{"change":3,"start":44535,"end":44535},"introduced_by":3}],"inode":{"change":3,"pos":44535}}},"content_edges":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":3,"pos":44535},"to":{"change":3,"start":44536,"end":45954},"introduced_by":3}],"inode":{"change":3,"pos":44535}},"content":[{"Del":"use clap::*;\nuse elpe::*;\nuse serde_derive::*;\nuse std::path::PathBuf;\nuse tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};\n\nmod server;\n\n#[derive(Deserialize)]\npub struct Config {\n pgp_home: PathBuf,\n store_path: PathBuf,\n package_index: String,\n user: String,\n}\n\n/// Elpe\n#[derive(Parser, Debug)]\n#[command(version, about, long_about = None)]\nstruct Args {\n /// Path to the configuration file\n #[arg(short, long)]\n config: PathBuf,\n}\n\nfn main() {\n tracing_subscriber::registry()\n .with(\n tracing_subscriber::EnvFilter::try_from_default_env()\n .unwrap_or_else(|_| String::new().into()),\n )\n .with(tracing_subscriber::fmt::layer())\n .init();\n\n let args = Args::parse();\n\n let config: Config = toml::from_str(&std::fs::read_to_string(&args.config).unwrap()).unwrap();\n\n let container_channel = crate::container::serve(&config.user, &config.store_path);\n\n let rt = tokio::runtime::Runtime::new().unwrap();\n rt.block_on(async move {\n privdrop::PrivDrop::default()\n .user(&config.user)\n .apply()\n .unwrap();\n\n let elpe = server::Elpe::new(\n Client::new(&config.pgp_home, &config.store_path, &config.package_index),\n container_channel,\n );\n\n let addr = \"0.0.0.0:50051\".parse().unwrap();\n elpe.serve(addr).await\n })\n}\n"}]}},{"FileDel":{"deleted_names":[{"basename":"server.rs~","metadata":0}],"del":{"EdgeMap":{"edges":[{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":2,"pos":15},"to":{"change":3,"start":45955,"end":45989},"introduced_by":3},{"previous":"BLOCK | FOLDER","flag":"BLOCK | FOLDER | DELETED","from":{"change":3,"pos":45989},"to":{"change":3,"start":45990,"end":45990},"introduced_by":3}],"inode":{"change":3,"pos":45990}}},"content_edges":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":3,"pos":45990},"to":{"change":3,"start":45991,"end":58250},"introduced_by":3}],"inode":{"change":3,"pos":45990}},"content":[{"Del":"use elpe::extract::*;\nuse elpe::*;\nuse std::sync::Arc;\nuse tokio::io::AsyncWriteExt;\nuse tokio_stream::wrappers::ReceiverStream;\nuse tokio_util::sync::PollSender;\nuse tonic::codegen::tokio_stream::StreamExt;\nuse tracing::*;\n\npub struct Elpe {\n deb_client: elpe::Client,\n sender: tokio::sync::mpsc::UnboundedSender<(\n crate::container::BuildRequest,\n tokio::sync::mpsc::Sender,\n )>,\n t: Option>>,\n}\n\npub mod proto {\n tonic::include_proto!(\"elpe\");\n}\n\nimpl Elpe {\n pub fn new(\n deb_client: elpe::Client,\n container_channel: elpe::container::ContainerChannel,\n ) -> Self {\n let (sender, receiver) = tokio::sync::mpsc::unbounded_channel::<(\n crate::container::BuildRequest,\n tokio::sync::mpsc::Sender,\n )>();\n\n let t = tokio::spawn(crate::container::forward(receiver, container_channel));\n\n Elpe {\n deb_client,\n sender,\n t: Some(t),\n }\n }\n\n pub async fn serve(mut self, addr: std::net::SocketAddr) {\n let t = self.t.take().unwrap();\n tokio::select! {\n _ = tonic::transport::Server::builder()\n .add_service(proto::elpe_server::ElpeServer::new(self))\n .serve(addr)\n => {}\n _ = t => {}\n }\n }\n}\n\nuse std::pin::Pin;\n\ntype ResponseStream =\n Pin> + Send>>;\n\n#[tonic::async_trait]\nimpl proto::elpe_server::Elpe for Elpe {\n async fn handshake(\n &self,\n request: tonic::Request,\n ) -> Result, tonic::Status> {\n Ok(proto::PlatformReply {\n endianness: if cfg!(target_endian = \"big\") { 0 } else { 1 },\n pointer_width: std::mem::size_of::() as i32,\n arch: match std::env::consts::ARCH {\n \"x86_64\" => 0,\n \"aarch64\" => 1,\n _ => unimplemented!(),\n },\n }\n .into())\n }\n\n async fn add_path(\n &self,\n request: tonic::Request>,\n ) -> Result, tonic::Status> {\n let mut r = request.into_inner();\n debug!(\"add_path\");\n let mut current_file = None;\n let ref store = self.deb_client.store_path();\n debug!(\"store\");\n let tmp_dir = tempfile::tempdir_in(store).unwrap();\n debug!(\"store {:?}\", tmp_dir);\n\n let mut hasher = blake3::Hasher::new();\n debug!(\"loop\");\n loop {\n trace!(\"waiting for next in stream\");\n let Some(r) = r.next().await else { break };\n let r = r.unwrap();\n match r.request {\n Some(proto::add_path_request::Request::File(f)) => {\n info!(\"Adding file {:?}\", f.name);\n hasher.update(b\"\\0f\");\n hasher.update(f.name.as_bytes());\n hasher.update(b\"\\0\");\n let p = tmp_dir.path().join(&f.name);\n tokio::fs::create_dir_all(p.parent().unwrap()).await?;\n current_file = Some(tokio::fs::File::create(&p).await?)\n }\n Some(proto::add_path_request::Request::Directory(d)) => {\n info!(\"Adding file {:?}\", d.name);\n hasher.update(b\"\\0d\");\n hasher.update(d.name.as_bytes());\n hasher.update(b\"\\0\");\n let p = tmp_dir.path().join(&d.name);\n tokio::fs::create_dir_all(&p).await.unwrap();\n }\n Some(proto::add_path_request::Request::Contents(c)) => {\n hasher.update(&c.content);\n current_file.as_mut().unwrap().write_all(&c.content).await?;\n }\n None => break,\n }\n }\n debug!(\"loop done\");\n let path = store.join(data_encoding::HEXLOWER.encode(hasher.finalize().as_bytes()));\n use tokio::io::ErrorKind;\n let new = tmp_dir.into_path();\n match tokio::fs::rename(&new, &path).await {\n Ok(()) => (),\n Err(e) if e.kind() == ErrorKind::DirectoryNotEmpty => (),\n Err(e) => {\n tokio::fs::remove_dir_all(&new).await?;\n return Err(e.into());\n }\n }\n info!(\"add_path extracted to {:?}\", path);\n Ok(tonic::Response::new(proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Ok(\n proto::DerivationResult {\n destdir: vec![path.to_str().unwrap().to_string()],\n paths: Vec::new(),\n path_patterns: Vec::new(),\n },\n )),\n }))\n }\n\n type DerivationStream = ResponseStream;\n\n async fn derivation(\n &self,\n request: tonic::Request,\n ) -> Result, tonic::Status> {\n debug!(\"derivation request\");\n let now = std::time::Instant::now();\n let r = request.into_inner();\n let (tx, rx) = tokio::sync::mpsc::channel(200);\n debug!(\"derivation request: {:?} {:?}\", r.name, r.paths);\n self.sender\n .send((\n crate::container::BuildRequest {\n name: r.name.clone(),\n paths: r.paths,\n script: r.builder,\n target: r.target,\n output_hash: r.output_hash,\n },\n tx,\n ))\n .unwrap();\n use crate::container::Msg;\n let output_stream = ReceiverStream::new(rx).map(|x| {\n Ok(match x {\n Msg::Ok(out) => proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Ok(\n proto::DerivationResult {\n destdir: out\n .into_iter()\n .map(|x| x.to_str().unwrap().to_string())\n .collect(),\n paths: Vec::new(),\n path_patterns: Vec::new(),\n },\n )),\n },\n Msg::Error(p) => proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Error(p)),\n },\n Msg::Stdout(p) => proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Stdout(p)),\n },\n Msg::Stderr(p) => proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Stderr(p)),\n },\n })\n });\n info!(\"request {:?}: {:?}\", r.name, now.elapsed());\n Ok(tonic::Response::new(Box::pin(output_stream)))\n }\n\n async fn add_url(\n &self,\n request: tonic::Request,\n ) -> Result, tonic::Status> {\n let r = request.into_inner();\n debug!(\"add_url request {:?}\", r);\n let p = self\n .deb_client\n .http_download(\n &r.url,\n match r.hash_algorithm {\n 0 => {\n let mut h = [0; 32];\n h.clone_from_slice(&r.hash);\n Hash::Blake3(h)\n }\n 1 => {\n let mut h = [0; 32];\n h.clone_from_slice(&r.hash);\n Hash::Sha256(h)\n }\n 2 => {\n let mut h = [0; 64];\n h.clone_from_slice(&r.hash);\n Hash::Sha512(h)\n }\n _ => unreachable!(),\n },\n )\n .await\n .unwrap();\n Ok(tonic::Response::new(proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Ok(\n proto::DerivationResult {\n destdir: vec![p.to_str().unwrap().to_string()],\n paths: Vec::new(),\n path_patterns: Vec::new(),\n },\n )),\n }))\n }\n\n async fn ubuntu_release(\n &self,\n request: tonic::Request,\n ) -> Result, tonic::Status> {\n debug!(\"ubuntu release {:?}\", request);\n let now = std::time::Instant::now();\n let r = request.into_inner();\n let h = self.deb_client.in_release(r.release.clone()).await.unwrap();\n let arch = match r.arch {\n 0 => \"amd64\",\n 1 => \"arm64\",\n _ => unreachable!(),\n };\n let p = self\n .deb_client\n .packages(&h, &r.repository, arch)\n .await\n .expect(&format!(\"{} {}\", &r.repository,&arch));\n info!(\n \"ubuntu release request {:?}: {:?}\",\n r.release,\n now.elapsed()\n );\n Ok(tonic::Response::new(proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Ok(\n proto::DerivationResult {\n destdir: vec![p.to_str().unwrap().to_string()],\n paths: Vec::new(),\n path_patterns: Vec::new(),\n },\n )),\n }))\n }\n\n type UbuntuPackageStream = ResponseStream;\n\n async fn ubuntu_package(\n &self,\n request: tonic::Request,\n ) -> Result, tonic::Status> {\n let now = std::time::Instant::now();\n let r = request.into_inner();\n let index: Result, _> = r\n .index\n .into_iter()\n .map(|index| deb::Index::open(&index))\n .collect();\n let index = index.unwrap();\n\n let link_extra: Vec<_> = r\n .link_extra\n .into_iter()\n .map(|l| {\n (\n regex::Regex::new(&l.pkg).unwrap(),\n regex::Regex::new(&l.dep).unwrap(),\n )\n })\n .collect();\n\n let (tx, rx) = tokio::sync::mpsc::channel(200);\n use crate::extract::Msg;\n let output_stream = ReceiverStream::new(rx).map(|x| {\n Ok(match x {\n Msg::Downloading(p) => proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Loading(p)),\n },\n Msg::Ok(p) => proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Ok(\n proto::DerivationResult {\n destdir: p\n .result\n .iter()\n .rev()\n .map(|x| x.to_str().unwrap().to_string())\n .collect(),\n paths: p.paths.into_iter().filter_map(Arc::into_inner).collect(),\n path_patterns: Vec::new(),\n },\n )),\n },\n Msg::Error(e) => proto::DerivationReply {\n result: Some(proto::derivation_reply::Result::Error(e.to_string())),\n },\n })\n });\n\n match download_extract_deps(\n &index,\n &self.deb_client,\n &r.name,\n &link_extra,\n PollSender::new(tx.clone()),\n )\n .await\n {\n Ok(p) => {\n info!(\"path {:?} {:#?}\", r.name, p);\n tx.send(Msg::Ok(p)).await.unwrap();\n }\n Err(e) => tx.send(Msg::Error(e)).await.unwrap(),\n }\n\n info!(\"ubuntu package request {:?}: {:?}\", r.name, now.elapsed());\n\n Ok(tonic::Response::new(Box::pin(output_stream)))\n }\n}\n"}]}}],"owner":"pmeunier","repo":"elpe","token":"Nl5LjQ5s9EvijkQ/mpT8JawPliQBVL053ujrbZepvxg=","login":null}

…

Dependencies

Change contents