summaryrefslogtreecommitdiffstats
path: root/pkgs/by-name/ro/rollup/src/main.rs
diff options
context:
space:
mode:
Diffstat (limited to 'pkgs/by-name/ro/rollup/src/main.rs')
-rw-r--r--pkgs/by-name/ro/rollup/src/main.rs459
1 files changed, 459 insertions, 0 deletions
diff --git a/pkgs/by-name/ro/rollup/src/main.rs b/pkgs/by-name/ro/rollup/src/main.rs
new file mode 100644
index 00000000..28ef0fea
--- /dev/null
+++ b/pkgs/by-name/ro/rollup/src/main.rs
@@ -0,0 +1,459 @@
+use std::{
+ collections::HashMap,
+ env::current_dir,
+ ffi::OsStr,
+ fs,
+ io::Write,
+ path::{Path, PathBuf},
+ process::{Command, Stdio},
+};
+
+use anyhow::{Context, Result, bail};
+use clap::{Parser, Subcommand};
+
+use crate::{
+ config::{DROP_IN_NAME, DropInConfig, MAIN_CONFIG_NAME, MainConfig, Owner},
+ parse::{FileDiff, Patch},
+};
+
+mod config;
+mod parse;
+
+#[derive(Parser)]
+struct Cli {
+ /// Don't actually do anything, just check'
+ #[arg(long, global = true)]
+ dry_run: bool,
+
+ #[command(subcommand)]
+ subcommand: Cmd,
+}
+
+#[derive(Subcommand)]
+enum Cmd {
+ /// Apply patches to a rollup target.
+ Apply {
+ /// The files to pull the patches to rollup from.
+ patch_files: Vec<PathBuf>,
+
+ /// Which repository to use as a target for the rollup
+ /// It is specified via the owner, declared in the rollup.toml config.
+ ///
+ /// The repository needs to be clean.
+ #[arg(short, long)]
+ to: String,
+
+ /// Show debug information related to the parsing of patch files.
+ #[arg(short, long)]
+ debug_parse: bool,
+ },
+
+ /// Create the patch files (based on the given tag)
+ Create {
+ /// Which repository to use for the tag to base created tags on.
+ /// It is specified via the owner, declared in the rollup.toml config.
+ ///
+ /// The repository needs to be clean.
+ #[arg(short, long)]
+ to: String,
+ },
+
+ /// First create the patches, and then automatically apply them.
+ CreateApply {
+ /// Which repository to use as a target for the rollup and the tag for new
+ /// patches.
+ /// It is specified via the owner, declared in the rollup.toml config.
+ ///
+ /// The repository needs to be clean.
+ #[arg(short, long)]
+ to: String,
+
+ /// Show debug information related to the parsing of patch files.
+ #[arg(short, long)]
+ debug_parse: bool,
+ },
+}
+
+macro_rules! git {
+ (@_base for $finalizer:ident in $to:expr; $($args:expr),*) => {
+ Command::new("git")
+ .args([
+ "-C",
+ $to.display().to_string().as_str(),
+ $($args),*
+ ])
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .$finalizer()
+ .with_context(|| format!("Failed to run {}", git!(@_fmt_cmd $($args),*)))?
+ };
+ (@_handle_status $output:expr; $($args:expr),*) => {{
+ if !$output.status.success() {
+ bail!(
+ "{} failed!\n\nStderr was:\n {}",
+ git!(@_fmt_cmd $($args),*),
+ String::from_utf8($output.stderr).unwrap()
+ )
+ }
+ if !$output.stderr.is_empty() {
+ let stderr = String::from_utf8($output.stderr).expect("git should always produce utf8");
+ bail!("{} returned some errors:\n{stderr}", git!(@_fmt_cmd $($args),*));
+ }
+ }};
+ (@_fmt_cmd $($args:expr),*) => {{
+ let all = ["git", $($args),*].join(" ");
+ format!("`{}`", all)
+ }};
+ (in $to:expr; $($args:expr),*) => {{
+ let output = git!(@_base for output in $to; $($args),*);
+ git!(@_handle_status output; $($args),*);
+
+ let stdout = String::from_utf8(output.stdout).expect("git should always produce utf8");
+ let stderr = String::from_utf8(output.stderr).expect("git should always produce utf8");
+
+ (stdout, stderr)
+ }};
+ (@set_stdin_to $stdin:expr; in $to:expr; $($args:expr),*) => {{
+ let mut child = git!(@_base for spawn in $to; $($args),*);
+ let mut stdin = child.stdin.take().expect("is piped");
+ write!(stdin, "{}", $stdin)?;
+ drop(stdin);
+ let output = child.wait_with_output()
+ .with_context(|| format!("Failed to run `{}`", git!(@_fmt_cmd $($args),*)))?;
+ git!(@_handle_status output; $($args),*);
+
+ let stdout = String::from_utf8(output.stdout).expect("git should always produce utf8");
+ let stderr = String::from_utf8(output.stderr).expect("git should always produce utf8");
+
+ (stdout, stderr)
+ }};
+}
+
+macro_rules! drop_msg {
+ ($fmt:literal, $($args:expr),*) => {
+ eprintln!(" > {}", format!($fmt, $($args),*));
+ };
+}
+
+fn main() -> Result<()> {
+ let args = Cli::parse();
+ let root = {
+ let (stdout, _) = git!(in current_dir()?; "rev-parse", "--show-toplevel");
+ PathBuf::from(stdout.trim())
+ };
+ let config = config::load(&root).with_context(|| {
+ format!(
+ "Failed to load the config (`{MAIN_CONFIG_NAME}`), in root: `{}`",
+ root.display()
+ )
+ })?;
+
+ match args.subcommand {
+ Cmd::Apply {
+ patch_files,
+ to,
+ debug_parse,
+ } => {
+ let owner = config.get_owner(&to)?;
+ check_owner(owner)?;
+ apply_patches(patch_files, owner, debug_parse, &config, root, args.dry_run)?
+ }
+ Cmd::Create { to } => {
+ let owner = config.get_owner(&to)?;
+ create_patches(&owner.last_applied_tag, args.dry_run)?;
+ }
+ Cmd::CreateApply { to, debug_parse } => {
+ let owner = config.get_owner(&to)?;
+ check_owner(owner)?;
+
+ let Some(patches_directory) = create_patches(&owner.last_applied_tag, args.dry_run)?
+ else {
+ return Ok(());
+ };
+
+ let patch_files = {
+ let iter = fs::read_dir(&patches_directory)?;
+ let mut output = vec![None; iter.count()];
+
+ let iter = fs::read_dir(patches_directory)?;
+ for entry in iter {
+ let entry = entry?;
+ if !entry.file_type()?.is_file() {
+ unreachable!("Should not be able to get non-files in patches directory");
+ }
+ let path = entry.path();
+ let idx: usize = {
+ let mut file_name = path
+ .file_name()
+ .expect("Should all have a filename")
+ .to_str()
+ .expect("Should be valid utf8")
+ .chars();
+ let number = file_name.clone().take(4).collect::<String>();
+ assert_eq!(file_name.nth(4), Some('-'));
+
+ number.parse().expect("Should parse as usize number")
+ };
+ output[idx - 1] = Some(path);
+ }
+ output.sort();
+ output
+ };
+ apply_patches(
+ patch_files.into_iter().map(|s| s.unwrap()).collect(),
+ owner,
+ debug_parse,
+ &config,
+ root,
+ args.dry_run,
+ )?;
+ }
+ }
+
+ Ok(())
+}
+
+fn create_patches(tag: &str, dry_run: bool) -> Result<Option<PathBuf>> {
+ let current_dir = current_dir()?;
+
+ let (stdout, _) = git!(in current_dir; "tag", "--contains", "HEAD", tag);
+ if !stdout.is_empty() {
+ println!(
+ "There are no tags to generate. Tag {} already points to HEAD.",
+ tag
+ );
+ return Ok(None);
+ }
+
+ let mktemp = Command::new("mktemp")
+ .args(["-t", "rollup_patches_XXXXXX", "-d"])
+ .output()
+ .context("Failed to run `mktemp -t rollup_patches_XXXXXX -d`")?;
+ if !mktemp.status.success() {
+ bail!("Failed to generate temp-directory for generated patches.");
+ }
+
+ let tempdir = PathBuf::from(String::from_utf8(mktemp.stdout).unwrap().trim());
+
+ git!(in current_dir; "format-patch", format!("{}..", tag).as_str(), "-o", tempdir.display().to_string().as_str());
+
+ if dry_run {
+ eprintln!("Dry-run is on; Not actually moving patch tag `{tag}` forward.")
+ } else {
+ git!(in current_dir; "tag", "--delete", tag);
+ git!(in current_dir; "tag", "--annotate", tag, "-m", "");
+ }
+
+ println!("Patches have been generated here: `{}`", tempdir.display());
+
+ Ok(Some(tempdir))
+}
+
+fn apply_patches(
+ patch_files: Vec<PathBuf>,
+ owner: &Owner,
+ debug_parse: bool,
+ config: &MainConfig,
+ root: PathBuf,
+ dry_run: bool,
+) -> Result<()> {
+ let applies_to = &owner.applies_to;
+
+ let mut patches = vec![];
+ for file in &patch_files {
+ patches.push(parse::parse_file(file, debug_parse)?);
+ }
+
+ eprintln!("Successfully parsed all {} patch files.", patches.len());
+
+ {
+ let (stdout, _) = git!(in applies_to; "status", "--porcelain");
+ if !stdout.is_empty() {
+ bail!(
+ "`--to` (`{}`) workspace is dirty, refusing to continue.",
+ applies_to.display()
+ );
+ }
+ }
+
+ for (idx, patch) in patches.iter().enumerate() {
+ eprintln!(
+ "Applying {}. patch: `{}`... ",
+ idx + 1,
+ patch_files[idx]
+ .file_name()
+ .expect("Has a file name")
+ .display()
+ );
+
+ let mut final_diffs = vec![];
+ for file_diff in &patch.files {
+ match file_diff {
+ FileDiff::Add { path, .. } => {
+ if applies_to.join(path).exists() {
+ bail!("A file was added, that already existed. This should be impossible.")
+ }
+ if drop_in_applies(&config.drop_ins, owner, &root, path)? {
+ final_diffs.push(file_diff.to_owned());
+ }
+ }
+ FileDiff::Remove { path, .. } => {
+ if applies_to.join(path).exists() {
+ if drop_in_applies(&config.drop_ins, owner, &root, path)? {
+ final_diffs.push(file_diff.to_owned());
+ }
+ } else {
+ drop_msg!(
+ "Dropping remove of `{}`, as the file does not exist in the rollup target.",
+ path.display()
+ );
+ }
+ }
+ FileDiff::RenameNoChange { from, to, .. }
+ | FileDiff::RenameWithChange { from, to, .. } => {
+ if applies_to.join(from).exists() {
+ if applies_to.join(to).exists() {
+ bail!(
+ "A rename (`{}` -> `{}`) tried to rename a path to an already existing path. This should be impossible.",
+ from.display(),
+ to.display()
+ )
+ }
+ if drop_in_applies(&config.drop_ins, owner, &root, to)? {
+ final_diffs.push(file_diff.to_owned());
+ }
+ } else {
+ drop_msg!(
+ "Dropping rename from `{}` to `{}`, as the from file does not exist in the rollup target.",
+ from.display(),
+ to.display()
+ );
+ }
+ }
+ FileDiff::Change { path, .. } => {
+ if applies_to.join(path).exists() {
+ if drop_in_applies(&config.drop_ins, owner, &root, path)? {
+ final_diffs.push(file_diff.to_owned());
+ }
+ } else {
+ drop_msg!(
+ "Dropping change to `{}`, as the file does not exist in the rollup target.",
+ path.display()
+ );
+ }
+ }
+ }
+ }
+
+ if final_diffs.is_empty() {
+ eprintln!(" -> Patch is empty after dropping, skipping it.",);
+ continue;
+ }
+
+ let filtered_patch = Patch {
+ files: final_diffs,
+ ..patch.to_owned()
+ };
+
+ if dry_run {
+ eprintln!(" (Dry-run is on; Not applying.)");
+ } else {
+ git!(@set_stdin_to filtered_patch; in applies_to; "apply", "-", "--whitespace=nowarn");
+ git!(in applies_to; "add", ".");
+ git!(@set_stdin_to filtered_patch.commit_message; in applies_to; "commit", "--file=-", format!("--date={}", filtered_patch.date).as_str(), "--quiet");
+ }
+ }
+
+ Ok(())
+}
+
+fn check_owner(owner: &Owner) -> Result<()> {
+ let to = &owner.applies_to;
+ let to = to.join(".git");
+
+ // NOTE: We cannot just try to stat() the path, because landlock might be in use and does not
+ // currently deny that (tracked in: https://github.com/landlock-lsm/linux/issues/52) <2026-11-09>
+ // So we instead try to list it.
+ let is_listable = {
+ let dir_entries = fs::read_dir(&to).with_context(|| {
+ format!(
+ "Failed check regarding `--to` directory (`{}`) readability. Are you in a sandbox?",
+ to.display()
+ )
+ })?;
+ dir_entries.count() > 0
+ };
+
+ if !is_listable {
+ bail!("To directory (`{}`) is not readable", to.display());
+ }
+
+ Ok(())
+}
+
+fn drop_in_applies(
+ drop_ins: &HashMap<PathBuf, DropInConfig>,
+ owner: &Owner,
+ root: &Path,
+ original_path: &Path,
+) -> Result<bool> {
+ let path = &original_path.canonicalize()?;
+
+ let file_name = path.file_name().expect("All paths are to files");
+ if file_name == OsStr::new(DROP_IN_NAME) || file_name == OsStr::new(MAIN_CONFIG_NAME) {
+ drop_msg!(
+ "Not applying change to `{}`, because it's a rollup config or drop in.",
+ path.display()
+ );
+
+ return Ok(false);
+ }
+
+ if path.parent() == Some(root) {
+ return Ok(true);
+ }
+
+ let path = PathBuf::from(
+ &path
+ .display()
+ .to_string()
+ .strip_prefix(format!("{}/", root.display()).as_str())
+ .expect("All paths are in root"),
+ );
+
+ if let Some(conf) = drop_ins.get(&path)
+ && conf.owners.contains(&owner.name)
+ {
+ return Ok(true);
+ }
+
+ let mut parent: &Path = &path;
+ while let Some(next) = parent.parent() {
+ // eprintln!("Checking `{}` for drop-ins..", next.display());
+
+ if let Some(conf) = drop_ins.get(&root.join(next)) {
+ // eprint!("Found a drop-in for `{}`", next.display());
+ if !conf.owners.contains(&owner.name) {
+ // eprintln!(", but it's for `{}`, so ignoring path.", conf.owner);
+ drop_msg!(
+ "Dropping `{}` as `{}` says this dir is for `{}` (but we look for `{}`).",
+ original_path.display(),
+ next.join(DROP_IN_NAME).display(),
+ conf.owners.join(", "),
+ owner.name
+ );
+ return Ok(false);
+ } else {
+ // eprintln!(", which matches.");
+ return Ok(true);
+ }
+ }
+ parent = next;
+ }
+
+ bail!(
+ "There was no drop-in config defining path ownership for: `{}`",
+ path.display()
+ );
+}