Implement push

Author: Kobzol

src/bin/josh_sync.rs

@@ -2,7 +2,7 @@ use anyhow::Context;
 use clap::Parser;
 use josh_sync::config::{JoshConfig, load_config};
 use josh_sync::josh::{JoshProxy, try_install_josh};
-use josh_sync::sync::{GitSync, RustcPullError};
+use josh_sync::sync::{GitSync, RustcPullError, UPSTREAM_REPO};
 use josh_sync::utils::prompt;
 use std::path::{Path, PathBuf};
 
@@ -18,12 +18,23 @@ struct Args {
 enum Command {
     /// Initialize a config file for this repository.
     Init,
-    /// Pull changes from the main `rustc` repository.
+    /// Pull changes from the main `rust-lang/rust` repository.
     /// This creates new commits that should be then merged into this subtree repository.
     Pull {
         #[clap(long, default_value(DEFAULT_CONFIG_PATH))]
         config: PathBuf,
     },
+    /// Push changes into the main `rust-lang/rust` repository `branch` of a `rustc` fork under
+    /// the given GitHub `username`.
+    /// The pushed branch should then be merged into the `rustc` repository.
+    Push {
+        #[clap(long, default_value(DEFAULT_CONFIG_PATH))]
+        config: PathBuf,
+        /// Branch that should be pushed to your remote
+        branch: String,
+        /// Your GitHub usename where the fork is located
+        username: String,
+    },
 }
 
 fn main() -> anyhow::Result<()> {
@@ -48,7 +59,11 @@ fn main() -> anyhow::Result<()> {
             let sync = GitSync::new(config.clone(), josh);
             match sync.rustc_pull() {
                 Ok(result) => {
-                    maybe_create_gh_pr(&config.config, &result.merge_commit_message)?;
+                    maybe_create_gh_pr(
+                        &config.config.full_repo_name(),
+                        "Rustc pull update",
+                        &result.merge_commit_message,
+                    )?;
                 }
                 Err(RustcPullError::NothingToPull) => {
                     eprintln!("Nothing to pull");
@@ -60,35 +75,55 @@ fn main() -> anyhow::Result<()> {
                 }
             }
         }
+        Command::Push {
+            username,
+            branch,
+            config,
+        } => {
+            let config = load_config(&config)
+                .context("cannot load config. Run the `init` command to initialize it.")?;
+            let josh = get_josh_proxy()?;
+            let sync = GitSync::new(config.clone(), josh);
+            sync.rustc_push(&username, &branch)
+                .context("cannot perform push")?;
+
+            // Open PR with `subtree update` title to silence the `no-merges` triagebot check
+            println!(
+                r#"You can create the rustc PR using the following URL:
+https://github.com/{UPSTREAM_REPO}/compare/{username}:{branch}?quick_pull=1&title={}+subtree+update&body=r?+@ghost"#,
+                config.config.repo
+            );
+        }
     }
 
     Ok(())
 }
 
-fn maybe_create_gh_pr(config: &JoshConfig, pr_description: &str) -> anyhow::Result<()> {
+fn maybe_create_gh_pr(repo: &str, title: &str, description: &str) -> anyhow::Result<bool> {
     let gh_available = which::which("gh").is_ok();
     if !gh_available {
         println!(
             "Note: if you install the `gh` CLI tool, josh-sync will be able to create the sync PR for you."
         );
+        Ok(false)
     } else if prompt("Do you want to create a rustc pull PR using the `gh` tool?") {
-        let repo = config.full_repo_name();
         std::process::Command::new("gh")
             .args(&[
                 "pr",
                 "create",
                 "--title",
-                "Rustc pull update",
+                title,
                 "--body",
-                pr_description,
+                description,
                 "--repo",
-                &repo,
+                repo,
             ])
             .spawn()?
             .wait()?;
+        Ok(true)
+    } else {
+        Ok(false)
     }
-
-    Ok(())
 }
 
 fn get_josh_proxy() -> anyhow::Result<JoshProxy> {

src/josh.rs

@@ -82,9 +82,10 @@ pub struct RunningJoshProxy {
 }
 
 impl RunningJoshProxy {
-    pub fn git_url(&self, upstream_repo: &str, commit: &str, filter: &str) -> String {
+    pub fn git_url(&self, repo: &str, commit: Option<&str>, filter: &str) -> String {
+        let commit = commit.map(|c| format!("@{c}")).unwrap_or_default();
         format!(
-            "http://localhost:{}/{upstream_repo}.git@{commit}{filter}.git",
+            "http://localhost:{}/{repo}.git{commit}{filter}.git",
             self.port
         )
     }

src/sync.rs

@@ -1,9 +1,10 @@
 use crate::config::JoshConfigWithPath;
 use crate::josh::JoshProxy;
-use crate::utils::{check_output, ensure_clean_git_state};
+use crate::utils::{check_output, check_output_at, ensure_clean_git_state};
 use anyhow::{Context, Error};
+use std::path::{Path, PathBuf};
 
-const UPSTREAM_REPO: &str = "rust-lang/rust";
+pub const UPSTREAM_REPO: &str = "rust-lang/rust";
 
 pub enum RustcPullError {
     /// No changes are available to be pulled.
@@ -62,7 +63,7 @@ impl GitSync {
             .context("cannot start josh-proxy")?;
         let josh_url = josh.git_url(
             UPSTREAM_REPO,
-            &upstream_sha,
+            Some(&upstream_sha),
             &construct_filter(&self.config.config.path),
         );
 
@@ -178,6 +179,131 @@ Filtered ref: {incoming_ref}
             merge_commit_message: merge_message,
         })
     }
+
+    pub fn rustc_push(&self, username: &str, branch: &str) -> anyhow::Result<()> {
+        ensure_clean_git_state();
+
+        let base_upstream_sha = self
+            .config
+            .config
+            .last_upstream_sha
+            .clone()
+            .unwrap_or_default();
+
+        // Make sure josh is running.
+        let josh = self
+            .proxy
+            .start(&self.config.config)
+            .context("cannot start josh-proxy")?;
+        let josh_url = josh.git_url(
+            &format!("{username}/rust"),
+            None,
+            &construct_filter(&self.config.config.path),
+        );
+        let user_upstream_url = format!("https://github.com/{username}/rust");
+
+        let rustc_git = prepare_rustc_checkout().context("cannot prepare rustc checkout")?;
+
+        // Prepare the branch. Pushing works much better if we use as base exactly
+        // the commit that we pulled from last time, so we use the `rust-version`
+        // file to find out which commit that would be.
+        println!("Preparing {user_upstream_url} (base: {base_upstream_sha})...");
+
+        // Check if the remote branch doesn't already exist
+        if check_output_at(
+            &["git", "fetch", &user_upstream_url, branch],
+            &rustc_git,
+            true,
+        )
+        .is_ok()
+        {
+            return Err(anyhow::anyhow!(
+                "The branch '{branch}' seems to already exist in '{user_upstream_url}'. Please delete it and try again."
+            ));
+        }
+
+        // Download the base upstream SHA
+        check_output_at(
+            &[
+                "git",
+                "fetch",
+                &format!("https://github.com/{UPSTREAM_REPO}"),
+                &base_upstream_sha,
+            ],
+            &rustc_git,
+            false,
+        )
+        .context("cannot download latest upstream SHA")?;
+
+        // And push it to the user's fork's branch
+        check_output_at(
+            &[
+                "git",
+                "push",
+                &user_upstream_url,
+                &format!("{base_upstream_sha}:refs/heads/{branch}"),
+            ],
+            &rustc_git,
+            true,
+        )
+        .context("cannot push to your fork")?;
+        println!();
+
+        // Do the actual push from the subtree git repo
+        println!("Pushing changes...");
+        check_output(&["git", "push", &josh_url, &format!("HEAD:{branch}")])?;
+        println!();
+
+        // Do a round-trip check to make sure the push worked as expected.
+        check_output_at(
+            &["git", "fetch", &josh_url, &branch],
+            &std::env::current_dir().unwrap(),
+            true,
+        )?;
+        let head = check_output(&["git", "rev-parse", "HEAD"])?;
+        let fetch_head = check_output(&["git", "rev-parse", "FETCH_HEAD"])?;
+        if head != fetch_head {
+            return Err(anyhow::anyhow!(
+                "Josh created a non-roundtrip push! Do NOT merge this into rustc!\n\
+                Expected {head}, got {fetch_head}."
+            ));
+        }
+        println!(
+            "Confirmed that the push round-trips back to {} properly. Please create a rustc PR.",
+            self.config.config.repo
+        );
+
+        Ok(())
+    }
+}
+
+/// Find a rustc repo we can do our push preparation in.
+fn prepare_rustc_checkout() -> anyhow::Result<PathBuf> {
+    if let Ok(rustc_git) = std::env::var("RUSTC_GIT") {
+        let rustc_git = PathBuf::from(rustc_git);
+        assert!(
+            rustc_git.is_dir(),
+            "rustc checkout path must be a directory"
+        );
+        return Ok(rustc_git);
+    };
+
+    // Otherwise, download it
+    let path = "rustc-checkout";
+    if !Path::new(path).join(".git").exists() {
+        println!(
+            "Cloning rustc into `{path}`. Use RUSTC_GIT environment variable to override the location of the checkout"
+        );
+        check_output(&[
+            "git",
+            "clone",
+            "--filter=blob:none",
+            "https://github.com/rust-lang/rust",
+            path,
+        ])
+        .context("cannot clone rustc")?;
+    }
+    Ok(PathBuf::from(path))
 }
 
 /// Removes the last commit on drop, unless `disarm` is called first.

src/utils.rs

@@ -1,22 +1,36 @@
+use std::path::Path;
 use std::process::{Command, Stdio};
 
-/// Run a command from an array, collecting its output.
-pub fn check_output<'a, Args: AsRef<[&'a str]>>(l: Args) -> anyhow::Result<String> {
-    let args = l.as_ref();
+/// Run command and return its stdout.
+pub fn check_output<'a, Args: AsRef<[&'a str]>>(args: Args) -> anyhow::Result<String> {
+    check_output_at(args, &std::env::current_dir()?, false)
+}
+
+pub fn check_output_at<'a, Args: AsRef<[&'a str]>>(
+    args: Args,
+    workdir: &Path,
+    ignore_stderr: bool,
+) -> anyhow::Result<String> {
+    let args = args.as_ref();
 
     let mut cmd = Command::new(args[0]);
+    cmd.current_dir(workdir);
     cmd.args(&args[1..]);
-    cmd.stderr(Stdio::inherit());
+
+    if ignore_stderr {
+        cmd.stderr(Stdio::null());
+    }
     eprintln!("+ {cmd:?}");
     let out = cmd.output().expect("command failed");
     let stdout = String::from_utf8_lossy(out.stdout.trim_ascii()).to_string();
     if !out.status.success() {
-        panic!(
+        Err(anyhow::anyhow!(
             "Command `{cmd:?}` failed with exit code {:?}. STDOUT:\n{stdout}",
             out.status.code()
-        );
+        ))
+    } else {
+        Ok(stdout)
     }
-    Ok(stdout)
 }
 
 /// Fail if there are files that need to be checked in.