Merge pull request #46 from Mark-Simulacrum/promote-branches

Support branch promotion

Author: pietroalbini

src/branching.rs

@@ -0,0 +1,72 @@
+use crate::Context;
+
+impl Context {
+    /// Let $stable, $beta, $master be the tips of each branch (when starting).
+    ///
+    /// * Set stable to $beta.
+    /// * Set beta to $master (ish, look for the version bump).
+    /// * Create a rust-lang/cargo branch for the appropriate beta commit.
+    /// * Post a PR against the newly created beta branch bump src/ci/channel to `beta`.
+    pub fn do_branching(&mut self) -> anyhow::Result<()> {
+        let mut github = if let Some(github) = self.config.github() {
+            github
+        } else {
+            eprintln!("Skipping branching -- github credentials not configured");
+            return Ok(());
+        };
+        let mut token = github.token("rust-lang/rust")?;
+        let prebump_sha = token.last_commit_for_file("src/version")?;
+        let beta_sha = token.get_ref("heads/beta")?;
+
+        let stable_version = token.read_file(Some("stable"), "src/version")?;
+        let beta_version = token.read_file(Some("beta"), "src/version")?;
+        let future_beta_version = token.read_file(Some(&prebump_sha), "src/version")?;
+
+        // Check that we've not already promoted. Rather than trying to assert
+        // +1 version numbers, we instead have a simpler check that all the
+        // versions are unique -- before promotion we should have:
+        //
+        // * stable @ 1.61.0
+        // * beta @ 1.62.0
+        // * prebump @ 1.63.0
+        //
+        // and after promotion we will have (if we were to read the files again):
+        //
+        // * stable @ 1.62.0
+        // * beta @ 1.63.0
+        // * prebump @ 1.63.0
+        //
+        // In this state, if we try to promote again, we want to bail out. The
+        // stable == beta check isn't as useful, but still nice to have.
+        if stable_version.content()? == beta_version.content()? {
+            anyhow::bail!(
+                "Stable and beta have the same version: {}; refusing to promote branches.",
+                stable_version.content()?.trim()
+            );
+        }
+        if beta_version.content()? == future_beta_version.content()? {
+            anyhow::bail!(
+                "Beta and pre-bump master ({}) have the same version: {}; refusing to promote branches.",
+                prebump_sha,
+                beta_version.content()?.trim()
+            );
+        }
+
+        // No need to disable branch protection, as the promote-release app is
+        // specifically authorized to force-push to these branches.
+        token.update_ref("heads/stable", &beta_sha, true)?;
+        token.update_ref("heads/beta", &prebump_sha, true)?;
+
+        let cargo_sha = token
+            .read_file(Some(&prebump_sha), "src/tools/cargo")?
+            .submodule_sha()
+            .to_owned();
+
+        let mut github = self.config.github().unwrap();
+        let mut token = github.token("rust-lang/cargo")?;
+        let new_beta = future_beta_version.content()?.trim().to_owned();
+        token.create_ref(&dbg!(format!("heads/rust-{}", new_beta)), &cargo_sha)?;
+
+        Ok(())
+    }
+}

src/config.rs

@@ -47,7 +47,40 @@ impl std::fmt::Display for Channel {
     }
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) enum Action {
+    /// This is the default action, what we'll do if the environment variable
+    /// isn't set. It takes the configured channel and pushes artifacts into the
+    /// appropriate buckets, taking care of other helper tasks along the way.
+    PromoteRelease,
+
+    /// This promotes the branches up a single release:
+    ///
+    /// Let $stable, $beta, $master be the tips of each branch (when starting).
+    ///
+    /// * Set stable to $beta.
+    /// * Set beta to $master (ish, look for the version bump).
+    /// * Create a rust-lang/cargo branch for the appropriate beta commit.
+    /// * Post a PR against the newly created beta branch bump src/ci/channel to `beta`.
+    PromoteBranches,
+}
+
+impl FromStr for Action {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        match input {
+            "promote-release" => Ok(Action::PromoteRelease),
+            "promote-branches" => Ok(Action::PromoteBranches),
+            _ => anyhow::bail!("unknown channel: {}", input),
+        }
+    }
+}
+
 pub(crate) struct Config {
+    /// This is the action we're expecting to take.
+    pub(crate) action: Action,
+
     /// The channel we're currently releasing.
     pub(crate) channel: Channel,
     /// CloudFront distribution ID for doc.rust-lang.org.
@@ -153,6 +186,7 @@ pub(crate) struct Config {
 impl Config {
     pub(crate) fn from_env() -> Result<Self, Error> {
         Ok(Self {
+            action: default_env("ACTION", Action::PromoteRelease)?,
             bypass_startup_checks: bool_env("BYPASS_STARTUP_CHECKS")?,
             channel: require_env("CHANNEL")?,
             cloudfront_doc_id: require_env("CLOUDFRONT_DOC_ID")?,

src/github.rs

@@ -226,6 +226,38 @@ impl RepositoryClient<'_> {
         Ok(())
     }
 
+    pub(crate) fn update_ref(&mut self, name: &str, sha: &str, force: bool) -> anyhow::Result<()> {
+        // This mostly exists to make sure the request is successful rather than
+        // really checking the created ref (which we already know).
+        #[derive(serde::Deserialize)]
+        struct CreatedRef {
+            #[serde(rename = "ref")]
+            #[allow(unused)]
+            ref_: String,
+        }
+        #[derive(serde::Serialize)]
+        struct UpdateRefInternal<'a> {
+            sha: &'a str,
+            force: bool,
+        }
+
+        self.start_new_request()?;
+        // We want curl to read the request body, so configure POST.
+        self.github.client.post(true)?;
+        // However, the actual request should be a PATCH request.
+        self.github.client.custom_request("PATCH")?;
+        self.github.client.url(&format!(
+            "https://api.github.com/repos/{repository}/git/refs/{name}",
+            repository = self.repo,
+        ))?;
+        self.github
+            .client
+            .with_body(UpdateRefInternal { sha, force })
+            .send_with_response::<CreatedRef>()?;
+
+        Ok(())
+    }
+
     pub(crate) fn workflow_dispatch(&mut self, workflow: &str, branch: &str) -> anyhow::Result<()> {
         #[derive(serde::Serialize)]
         struct Request<'a> {
@@ -309,6 +341,71 @@ impl RepositoryClient<'_> {
             .send()?;
         Ok(())
     }
+
+    /// Returns the last commit (SHA) on a repository's default branch which changed
+    /// the passed path.
+    pub(crate) fn last_commit_for_file(&mut self, path: &str) -> anyhow::Result<String> {
+        #[derive(serde::Deserialize)]
+        struct CommitData {
+            sha: String,
+        }
+        self.start_new_request()?;
+        self.github.client.get(true)?;
+        self.github.client.url(&format!(
+            "https://api.github.com/repos/{repo}/commits?path={path}",
+            repo = self.repo
+        ))?;
+        let mut commits = self
+            .github
+            .client
+            .without_body()
+            .send_with_response::<Vec<CommitData>>()?;
+        if commits.is_empty() {
+            anyhow::bail!("No commits for path {:?}", path);
+        }
+        Ok(commits.remove(0).sha)
+    }
+
+    /// Returns the contents of the file
+    pub(crate) fn read_file(&mut self, sha: Option<&str>, path: &str) -> anyhow::Result<GitFile> {
+        self.start_new_request()?;
+        self.github.client.get(true)?;
+        self.github.client.url(&format!(
+            "https://api.github.com/repos/{repo}/contents/{path}{maybe_ref}",
+            repo = self.repo,
+            maybe_ref = sha.map(|s| format!("?ref={}", s)).unwrap_or_default()
+        ))?;
+        self.github
+            .client
+            .without_body()
+            .send_with_response::<GitFile>()
+    }
+}
+
+#[derive(Debug, serde::Deserialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub(crate) enum GitFile {
+    File { encoding: String, content: String },
+    Submodule { sha: String },
+}
+
+impl GitFile {
+    pub(crate) fn submodule_sha(&self) -> &str {
+        if let GitFile::Submodule { sha } = self {
+            sha
+        } else {
+            panic!("{:?} not a submodule", self);
+        }
+    }
+
+    pub(crate) fn content(&self) -> anyhow::Result<String> {
+        if let GitFile::File { encoding, content } = self {
+            assert_eq!(encoding, "base64");
+            Ok(String::from_utf8(base64::decode(&content.trim())?)?)
+        } else {
+            panic!("content() on {:?}", self);
+        }
+    }
 }
 
 #[derive(Copy, Clone)]

src/main.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::rc_buffer)]
 
+mod branching;
 mod build_manifest;
 mod config;
 mod curl_helper;
@@ -71,8 +72,10 @@ impl Context {
 
     fn run(&mut self) -> Result<(), Error> {
         let _lock = self.lock()?;
-        self.do_release()?;
-
+        match self.config.action {
+            config::Action::PromoteRelease => self.do_release()?,
+            config::Action::PromoteBranches => self.do_branching()?,
+        }
         Ok(())
     }