Revert "old"

tgross35 · tgross35 · commit 89f7f7356449 · 2025-06-04T06:57:16.000Z
This reverts commit f5351f147a242fa466acbd951574888a91b2550b.
diff --git a/library/compiler-builtins/crates/josh-sync/src/sync.rs b/library/compiler-builtins/crates/josh-sync/src/sync.rs
@@ -1,169 +1,173 @@
-use std::io::Write;
+use std::io::{Write, stdout};
 use std::ops::Not;
 use std::path::PathBuf;
+use std::process::{Command, Stdio};
 use std::time::Duration;
-use std::{env, net, process};
+use std::{env, fs, net, process};
 
 use anyhow::{Context, anyhow, bail};
 use xshell::{Shell, cmd};
 
-/// Used for rustc syncs.
-const JOSH_FILTER: &str = ":/src/doc/rustc-dev-guide";
-const JOSH_PORT: u16 = 42042;
-const UPSTREAM_REPO: &str = "rust-lang/rust";
-
-pub enum RustcPullError {
-    /// No changes are available to be pulled.
-    NothingToPull,
-    /// A rustc-pull has failed, probably a git operation error has occurred.
-    PullFailed(anyhow::Error),
-}
-
-impl<E> From<E> for RustcPullError
-where
-    E: Into<anyhow::Error>,
-{
-    fn from(error: E) -> Self {
-        Self::PullFailed(error.into())
-    }
-}
+const PREPARING_COMMIT_MESSAGE: &str = "Preparing for merge from rustc";
+const MERGE_COMMIT_MESSAGE: &str = "Merge from rustc";
 
 pub struct GitSync {
     dir: PathBuf,
+    upstream_repo: String,
+    upstream_ref: String,
+    upstream_url: String,
+    josh_filter: String,
+    josh_port: u16,
+    josh_url_base: String,
 }
 
 /// This code was adapted from the miri repository
 /// (https://github.com/rust-lang/miri/blob/6a68a79f38064c3bc30617cca4bdbfb2c336b140/miri-script/src/commands.rs#L236).
 impl GitSync {
     pub fn from_current_dir() -> anyhow::Result<Self> {
+        let upstream_repo =
+            env::var("UPSTREAM_ORG").unwrap_or_else(|_| "rust-lang".to_owned()) + "/rust";
+        let josh_port = 42042;
         Ok(Self {
             dir: std::env::current_dir()?,
+            upstream_url: format!("https://github.com/{upstream_repo}/"),
+            upstream_repo,
+            upstream_ref: env::var("UPSTREAM_REF").unwrap_or_else(|_| "HEAD".to_owned()),
+            josh_filter: ":/library/compiler-builtins".to_owned(),
+            josh_port,
+            josh_url_base: format!("http://localhost:{josh_port}"),
         })
     }
 
     pub fn rustc_pull(&self, commit: Option<String>) -> Result<(), RustcPullError> {
+        let Self {
+            upstream_repo,
+            upstream_ref,
+            upstream_url,
+            josh_filter,
+            josh_url_base,
+            ..
+        } = self;
+
         let sh = Shell::new()?;
         sh.change_dir(&self.dir);
-        let commit = commit.map(Ok).unwrap_or_else(|| {
-            let rust_repo_head =
-                cmd!(sh, "git ls-remote https://github.com/{UPSTREAM_REPO}/ HEAD").read()?;
-            rust_repo_head
-                .split_whitespace()
+
+        let upstream_head = commit.unwrap_or_else(|| {
+            let out = cmd!(sh, "git ls-remote {upstream_url} {upstream_ref}")
+                .read()
+                .unwrap();
+            out.split_whitespace()
                 .next()
-                .map(|front| front.trim().to_owned())
-                .ok_or_else(|| anyhow!("Could not obtain Rust repo HEAD from remote."))
-        })?;
-        // Make sure the repo is clean.
-        if cmd!(sh, "git status --untracked-files=no --porcelain")
-            .read()?
-            .is_empty()
-            .not()
-        {
-            return Err(anyhow::anyhow!(
-                "working directory must be clean before performing rustc pull"
-            )
-            .into());
-        }
+                .unwrap_or_else(|| panic!("could not split output: '{out}'"))
+                .to_owned()
+        });
+
+        ensure_clean(&sh)?;
+
         // Make sure josh is running.
-        let josh = Self::start_josh()?;
+        let _josh = self.start_josh()?;
         let josh_url =
-            format!("http://localhost:{JOSH_PORT}/{UPSTREAM_REPO}.git@{commit}{JOSH_FILTER}.git");
+            format!("{josh_url_base}/{upstream_repo}.git@{upstream_head}{josh_filter}.git");
 
-        let previous_base_commit = sh.read_file("rust-version")?.trim().to_string();
-        if previous_base_commit == commit {
-            return Err(RustcPullError::NothingToPull);
-        }
+        let previous_base_commit = sh.read_file("rust-version").unwrap().trim().to_string();
+        assert_ne!(previous_base_commit, upstream_head, "nothing to pull");
+
+        let orig_head = cmd!(sh, "git rev-parse HEAD").read().unwrap();
 
         // Update rust-version file. As a separate commit, since making it part of
         // the merge has confused the heck out of josh in the past.
         // We pass `--no-verify` to avoid running git hooks.
         // We do this before the merge so that if there are merge conflicts, we have
         // the right rust-version file while resolving them.
-        sh.write_file("rust-version", format!("{commit}\n"))?;
-        const PREPARING_COMMIT_MESSAGE: &str = "Preparing for merge from rustc";
+        sh.write_file("rust-version", format!("{upstream_head}\n"))?;
         cmd!(
             sh,
             "git commit rust-version --no-verify -m {PREPARING_COMMIT_MESSAGE}"
         )
-        .run()
-        .context("FAILED to commit rust-version file, something went wrong")?;
+        .run()?;
 
         // Fetch given rustc commit.
         cmd!(sh, "git fetch {josh_url}")
             .run()
-            .inspect_err(|_| {
-                // Try to un-do the previous `git commit`, to leave the repo in the state we found it.
-                cmd!(sh, "git reset --hard HEAD^")
-                    .run()
-                    .expect("FAILED to clean up again after failed `git fetch`, sorry for that");
-            })
-            .context("FAILED to fetch new commits, something went wrong (committing the rust-version file has been undone)")?;
+            .expect("FAILED to fetch new commits, something went wrong");
+
+        // // Fetch given rustc commit.
+        // if let Err(e) = cmd!(sh, "git fetch {josh_url}").run() {
+        //     println!("FAILED to fetch new commits, something went wrong");
+
+        //     // Try to un-do the previous `git commit`, to leave the repo in the state we found it.
+        //     cmd!(sh, "git reset --hard {orig_head}")
+        //         .run()
+        //         .expect("FAILED to clean up again after failed `git fetch`, sorry for that");
+
+        //     println!("committing the rust-version file has been undone");
+        //     panic!("{e}");
+        // }
 
         // This should not add any new root commits. So count those before and after merging.
-        let num_roots = || -> anyhow::Result<u32> {
-            Ok(cmd!(sh, "git rev-list HEAD --max-parents=0 --count")
+        let num_roots = || -> u32 {
+            let out = cmd!(sh, "git rev-list HEAD --max-parents=0 --count")
                 .read()
-                .context("failed to determine the number of root commits")?
-                .parse::<u32>()?)
+                .expect("failed to determine the number of root commits");
+            out.parse::<u32>()
+                .unwrap_or_else(|e| panic!("failed to parse `out`: {e}"))
         };
-        let num_roots_before = num_roots()?;
+        let num_roots_before = num_roots();
 
         let sha = cmd!(sh, "git rev-parse HEAD")
             .output()
-            .context("FAILED to get current commit")?
+            .expect("FAILED to get current commit")
             .stdout;
 
         // Merge the fetched commit.
-        const MERGE_COMMIT_MESSAGE: &str = "Merge from rustc";
         cmd!(
             sh,
             "git merge FETCH_HEAD --no-verify --no-ff -m {MERGE_COMMIT_MESSAGE}"
         )
         .run()
-        .context("FAILED to merge new commits, something went wrong")?;
+        .expect("FAILED to merge new commits, something went wrong");
 
         let current_sha = cmd!(sh, "git rev-parse HEAD")
             .output()
             .context("FAILED to get current commit")?
             .stdout;
         if current_sha == sha {
-            cmd!(sh, "git reset --hard HEAD^")
+            cmd!(sh, "git reset --hard {orig_head}")
                 .run()
                 .expect("FAILED to clean up after creating the preparation commit");
             eprintln!(
-                "No merge was performed, no changes to pull were found. Rolled back the preparation commit."
+                "No merge was performed, no changes to pull were found. \
+                Rolled back the preparation commit."
             );
             return Err(RustcPullError::NothingToPull);
         }
 
         // Check that the number of roots did not increase.
-        if num_roots()? != num_roots_before {
+        if num_roots() != num_roots_before {
             return Err(anyhow::anyhow!(
                 "Josh created a new root commit. This is probably not the history you want."
             )
             .into());
         }
 
-        drop(josh);
         Ok(())
     }
 
     pub fn rustc_push(&self, github_user: &str, branch: &str) -> anyhow::Result<()> {
         let sh = Shell::new()?;
+        let Self {
+            upstream_repo,
+            josh_filter,
+            josh_url_base,
+            ..
+        } = self;
         sh.change_dir(&self.dir);
         let base = sh.read_file("rust-version")?.trim().to_owned();
-        // Make sure the repo is clean.
-        if cmd!(sh, "git status --untracked-files=no --porcelain")
-            .read()?
-            .is_empty()
-            .not()
-        {
-            bail!("working directory must be clean before running `rustc-push`");
-        }
+        ensure_clean(&sh)?;
+
         // Make sure josh is running.
-        let josh = Self::start_josh()?;
-        let josh_url =
-            format!("http://localhost:{JOSH_PORT}/{github_user}/rust.git{JOSH_FILTER}.git");
+        let josh = self.start_josh()?;
+        let josh_url = format!("{josh_url_base}/{github_user}/rust.git{josh_filter}.git");
 
         // Find a repo we can do our preparation in.
         if let Ok(rustc_git) = env::var("RUSTC_GIT") {
@@ -201,7 +205,7 @@ impl GitSync {
             );
             std::process::exit(1);
         }
-        cmd!(sh, "git fetch https://github.com/{UPSTREAM_REPO} {base}").run()?;
+        cmd!(sh, "git fetch https://github.com/{upstream_repo} {base}").run()?;
         cmd!(
             sh,
             "git push https://github.com/{github_user}/rust {base}:refs/heads/{branch}"
@@ -234,14 +238,14 @@ impl GitSync {
         );
         println!(
             // Open PR with `subtree update` title to silence the `no-merges` triagebot check
-            "    https://github.com/{UPSTREAM_REPO}/compare/{github_user}:{branch}?quick_pull=1&title=rustc-dev-guide+subtree+update&body=r?+@ghost"
+            "    https://github.com/{upstream_repo}/compare/{github_user}:{branch}?quick_pull=1&title=rustc-dev-guide+subtree+update&body=r?+@ghost"
         );
 
         drop(josh);
         Ok(())
     }
 
-    fn start_josh() -> anyhow::Result<impl Drop> {
+    fn start_josh(&self) -> anyhow::Result<impl Drop> {
         // Determine cache directory.
         let local_dir = {
             let user_dirs =
@@ -253,7 +257,7 @@ impl GitSync {
         let mut cmd = process::Command::new("josh-proxy");
         cmd.arg("--local").arg(local_dir);
         cmd.arg("--remote").arg("https://github.com");
-        cmd.arg("--port").arg(JOSH_PORT.to_string());
+        cmd.arg("--port").arg(self.josh_port.to_string());
         cmd.arg("--no-background");
         cmd.stdout(process::Stdio::null());
         cmd.stderr(process::Stdio::null());
@@ -296,7 +300,7 @@ impl GitSync {
         for _ in 0..100 {
             // This will generally fail immediately when the port is still closed.
             let josh_ready = net::TcpStream::connect_timeout(
-                &net::SocketAddr::from(([127, 0, 0, 1], JOSH_PORT)),
+                &net::SocketAddr::from(([127, 0, 0, 1], self.josh_port)),
                 Duration::from_millis(1),
             );
             if josh_ready.is_ok() {
@@ -307,4 +311,43 @@ impl GitSync {
         }
         bail!("Even after waiting for 1s, josh-proxy is still not available.")
     }
+
+    fn run(&self, prog: &str, f: impl FnOnce(&mut Command) -> &mut Command) -> String {
+        let mut cmd = Command::new(prog);
+        cmd.current_dir(&self.dir).stderr(Stdio::inherit());
+        f(&mut cmd);
+        eprintln!("+ {cmd:?}");
+        let out = cmd.output().expect("command failed");
+        assert!(out.status.success());
+        String::from_utf8(out.stdout).expect("non-UTF8 output")
+    }
+}
+
+fn ensure_clean(sh: &Shell) -> anyhow::Result<()> {
+    // Make sure the repo is clean.
+    if cmd!(sh, "git status --untracked-files=no --porcelain")
+        .read()?
+        .is_empty()
+        .not()
+    {
+        bail!("working directory must be clean before performing rustc pull");
+    }
+
+    Ok(())
+}
+
+pub enum RustcPullError {
+    /// No changes are available to be pulled.
+    NothingToPull,
+    /// A rustc-pull has failed, probably a git operation error has occurred.
+    PullFailed(anyhow::Error),
+}
+
+impl<E> From<E> for RustcPullError
+where
+    E: Into<anyhow::Error>,
+{
+    fn from(error: E) -> Self {
+        Self::PullFailed(error.into())
+    }
 }
