From cfbf7bc048170f481838fc3b627e72e599bc90f1 Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Fri, 29 Jul 2022 18:29:55 +0200
Subject: [PATCH 01/12] Refactor github handler to be able to handle more than
 1 payload kind

---
 site/src/api.rs                     |  6 +--
 site/src/request_handlers/github.rs | 66 +++++++++++++++++------------
 2 files changed, 41 insertions(+), 31 deletions(-)

diff --git a/site/src/api.rs b/site/src/api.rs
index f5a849e4f..1ccb3167d 100644
--- a/site/src/api.rs
+++ b/site/src/api.rs
@@ -397,9 +397,9 @@ pub mod github {
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct Request {
-        pub issue: Issue,
-        pub comment: Comment,
+    #[serde(untagged)]
+    pub enum Request {
+        Issue { issue: Issue, comment: Comment },
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index a0c5a4983..ece24f33b 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -25,43 +25,58 @@ pub async fn handle_github(
     ctxt: Arc<SiteCtxt>,
 ) -> ServerResult<github::Response> {
     log::info!("handle_github({:?})", request);
-    if request.comment.body.contains(" homu: ") {
-        if let Some(sha) = parse_homu_comment(&request.comment.body).await {
-            enqueue_sha(request.issue, &ctxt, sha).await?;
+    match request {
+        github::Request::Issue { issue, comment } => handle_issue(ctxt, issue, comment).await,
+    }
+}
+
+async fn handle_issue(
+    ctxt: Arc<SiteCtxt>,
+    issue: github::Issue,
+    comment: github::Comment,
+) -> ServerResult<github::Response> {
+    if comment.body.contains(" homu: ") {
+        if let Some(sha) = parse_homu_comment(&comment.body).await {
+            enqueue_sha(issue, &ctxt, sha).await?;
             return Ok(github::Response);
         }
     }
 
-    if !request.comment.body.contains("@rust-timer ") {
-        return Ok(github::Response);
+    if comment.body.contains("@rust-timer ") {
+        return handle_rust_timer(ctxt, comment, issue).await;
     }
 
-    if request.comment.author_association != github::Association::Owner
-        && !get_authorized_users()
-            .await?
-            .contains(&request.comment.user.id)
+    Ok(github::Response)
+}
+
+async fn handle_rust_timer(
+    ctxt: Arc<SiteCtxt>,
+    comment: github::Comment,
+    issue: github::Issue,
+) -> ServerResult<github::Response> {
+    if comment.author_association != github::Association::Owner
+        && !get_authorized_users().await?.contains(&comment.user.id)
     {
         post_comment(
             &ctxt.config,
-            request.issue.number,
+            issue.number,
             "Insufficient permissions to issue commands to rust-timer.",
         )
         .await;
         return Ok(github::Response);
     }
 
-    if let Some(captures) = BODY_QUEUE.captures(&request.comment.body) {
+    if let Some(captures) = BODY_QUEUE.captures(&comment.body) {
         let include = captures.get(1).map(|v| v.as_str());
         let exclude = captures.get(2).map(|v| v.as_str());
         let runs = captures.get(3).and_then(|v| v.as_str().parse::<i32>().ok());
         {
             let conn = ctxt.conn().await;
-            conn.queue_pr(request.issue.number, include, exclude, runs)
-                .await;
+            conn.queue_pr(issue.number, include, exclude, runs).await;
         }
         post_comment(
             &ctxt.config,
-            request.issue.number,
+            issue.number,
             "Awaiting bors try build completion.
 
 @rustbot label: +S-waiting-on-perf",
@@ -69,8 +84,7 @@ pub async fn handle_github(
         .await;
         return Ok(github::Response);
     }
-
-    if let Some(captures) = BODY_TRY_COMMIT.captures(&request.comment.body) {
+    if let Some(captures) = BODY_TRY_COMMIT.captures(&comment.body) {
         if let Some(commit) = captures.get(1).map(|c| c.as_str().to_owned()) {
             let include = captures.get(2).map(|v| v.as_str());
             let exclude = captures.get(3).map(|v| v.as_str());
@@ -78,43 +92,39 @@ pub async fn handle_github(
             let commit = commit.trim_start_matches("https://github.com/rust-lang/rust/commit/");
             {
                 let conn = ctxt.conn().await;
-                conn.queue_pr(request.issue.number, include, exclude, runs)
-                    .await;
+                conn.queue_pr(issue.number, include, exclude, runs).await;
             }
-            enqueue_sha(request.issue, &ctxt, commit.to_owned()).await?;
+            enqueue_sha(issue, &ctxt, commit.to_owned()).await?;
             return Ok(github::Response);
         }
     }
-
-    for rollup_merge in extract_make_pr_for(&request.comment.body) {
+    for rollup_merge in extract_make_pr_for(&comment.body) {
         let client = reqwest::Client::new();
         pr_and_try_for_rollup(
             &client,
             ctxt.clone(),
-            &request.issue.repository_url,
+            &issue.repository_url,
             &rollup_merge,
-            &request.comment.html_url,
+            &comment.html_url,
         )
         .await
         .map_err(|e| format!("{:?}", e))?;
     }
-
-    for rollup_merge in extract_update_pr_for(&request.comment.body) {
+    for rollup_merge in extract_update_pr_for(&comment.body) {
         // This just creates or updates the branch for this merge commit.
         // Intended for resolving the race condition of master merging in
         // between us updating the commit and merging things.
         let client = reqwest::Client::new();
-        let branch = branch_for_rollup(&client, &ctxt, &request.issue.repository_url, rollup_merge)
+        let branch = branch_for_rollup(&client, &ctxt, &issue.repository_url, rollup_merge)
             .await
             .map_err(|e| e.to_string())?;
         post_comment(
             &ctxt.config,
-            request.issue.number,
+            issue.number,
             &format!("Master base SHA: {}", branch.master_base_sha),
         )
         .await;
     }
-
     Ok(github::Response)
 }
 

From f8706329c94086f153baf7781140533e56f756d4 Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Sun, 31 Jul 2022 19:41:28 +0200
Subject: [PATCH 02/12] Add handler for push event

---
 site/src/api.rs                     |  39 +++++++++++
 site/src/github.rs                  | 104 ++++++++++++++++++++++++++++
 site/src/request_handlers/github.rs |  98 +++++++++++++++++++++++++-
 site/src/server.rs                  |   2 +-
 4 files changed, 239 insertions(+), 4 deletions(-)

diff --git a/site/src/api.rs b/site/src/api.rs
index 1ccb3167d..318220704 100644
--- a/site/src/api.rs
+++ b/site/src/api.rs
@@ -394,12 +394,51 @@ pub mod github {
         pub number: u32,
         pub comments_url: String,
         pub repository_url: String,
+        pub labels: Vec<Label>,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+    pub struct Label {
+        pub name: String,
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
     #[serde(untagged)]
     pub enum Request {
         Issue { issue: Issue, comment: Comment },
+        Push(Push),
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Push {
+        pub r#ref: String,
+        pub sender: Sender,
+        pub committer: Committer,
+        pub head_commit: HeadCommit,
+        pub before: String,
+        pub commits: Vec<Commit>,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Commit {
+        #[serde(rename = "id")]
+        pub sha: String,
+        pub message: String,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct HeadCommit {
+        pub message: String,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Sender {
+        pub login: String,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Committer {
+        pub username: String,
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/site/src/github.rs b/site/src/github.rs
index 9a3b1425a..b945f3b4e 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -296,6 +296,86 @@ pub async fn create_pr(
     Ok(response.json().await.context("deserializing failed")?)
 }
 
+#[derive(serde::Serialize)]
+struct UpdateBranchRequest<'a> {
+    sha: &'a str,
+    force: bool,
+}
+
+pub async fn update_branch(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    branch: &str,
+    sha: &str,
+) -> anyhow::Result<()> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/git/refs/{}", repository_url, branch);
+    let commit_response = client
+        .patch(&url)
+        .json(&UpdateBranchRequest { sha, force: true })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("PATCH git/refs failed")?;
+    if commit_response.status() != reqwest::StatusCode::OK {
+        anyhow::bail!("{:?} != 200 OK", commit_response.status());
+    }
+
+    Ok(())
+}
+
+#[derive(serde::Serialize)]
+struct MergeBranchRequest<'a> {
+    base: &'a str,
+    head: &'a str,
+    commit_message: &'a str,
+}
+#[derive(serde::Deserialize)]
+struct MergeBranchResponse {
+    sha: String,
+}
+
+pub async fn merge_branch(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    branch: &str,
+    sha: &str,
+    commit_message: &str,
+) -> anyhow::Result<String> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/merges", repository_url);
+    let response = client
+        .patch(&url)
+        .json(&MergeBranchRequest {
+            base: branch,
+            head: sha,
+            commit_message,
+        })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("POST git/commits failed")?;
+    if !response.status().is_success() {
+        anyhow::bail!("{:?} != 201 CREATED", response.status());
+    }
+
+    Ok(response.json::<MergeBranchResponse>().await?.sha)
+}
+
 #[derive(serde::Serialize)]
 struct CreateCommitRequest<'a> {
     message: &'a str,
@@ -346,6 +426,30 @@ pub async fn create_commit(
         .sha)
 }
 
+pub async fn get_issue(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    number: u64,
+) -> anyhow::Result<Issue> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/issues/{}", repository_url, number);
+    let response = client
+        .get(&url)
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("cannot get commit")?;
+
+    Ok(response.json().await?)
+}
+
 pub async fn get_commit(
     client: &reqwest::Client,
     ctxt: &SiteCtxt,
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index ece24f33b..beacd5f37 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -1,7 +1,7 @@
 use crate::api::{github, ServerResult};
 use crate::github::{
-    branch_for_rollup, enqueue_sha, get_authorized_users, parse_homu_comment, post_comment,
-    pr_and_try_for_rollup,
+    branch_for_rollup, enqueue_sha, get_authorized_users, get_commit, get_issue, merge_branch,
+    parse_homu_comment, post_comment, pr_and_try_for_rollup, update_branch,
 };
 use crate::load::SiteCtxt;
 
@@ -10,6 +10,8 @@ use std::sync::Arc;
 use regex::{Captures, Regex};
 
 lazy_static::lazy_static! {
+    static ref ROLLUP_PR_NUMBER: Regex =
+        Regex::new(r#"^Auto merge of #(\d+)"#).unwrap();
     static ref BODY_TRY_COMMIT: Regex =
         Regex::new(r#"(?:\W|^)@rust-timer\s+build\s+(\w+)(?:\W|$)(?:include=(\S+))?\s*(?:exclude=(\S+))?\s*(?:runs=(\d+))?"#).unwrap();
     static ref BODY_QUEUE: Regex =
@@ -27,9 +29,100 @@ pub async fn handle_github(
     log::info!("handle_github({:?})", request);
     match request {
         github::Request::Issue { issue, comment } => handle_issue(ctxt, issue, comment).await,
+        github::Request::Push(p) => handle_push(ctxt, p).await,
     }
 }
 
+async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<github::Response> {
+    let client = reqwest::Client::new();
+    let repository_url = "https://github.com/rust-lang-ci/rust";
+    if push.r#ref != "refs/heads/master"
+        || !is_rollup(&client, &ctxt, repository_url, &push).await?
+    {
+        return Ok(github::Response);
+    }
+
+    let previous_master = &push.before;
+    let rollup_merges = push
+        .commits
+        .iter()
+        .rev()
+        .skip(1) // skip the head commit
+        .take_while(|c| c.message.starts_with("Rollup merge of "))
+        .map(|c| &c.sha);
+
+    for rollup_merge in rollup_merges {
+        // Fetch the rollup merge commit which should have two parents.
+        // The first parent is in the chain of rollup merge commits all the way back to `previous_master`.
+        // The second parent is the head of the PR that was rolled up. We want the second parent.
+        let commit = get_commit(&client, &ctxt, repository_url, &rollup_merge)
+            .await
+            .map_err(|e| format!("Error getting rollup merge commit: {e:?}"))?;
+        assert!(
+            commit.parents.len() == 2,
+            "What we thought was a merge commit was not a merge commit"
+        );
+        let rolled_up_head = &commit.parents[1].sha;
+
+        // Reset perf-tmp to the previous master
+        update_branch(&client, &ctxt, repository_url, "perf-tmp", previous_master)
+            .await
+            .map_err(|e| format!("Error updating perf-tmp with previous master: {e:?}"))?;
+
+        // Merge in the rolled up PR's head commit into the previous master
+        let sha = merge_branch(
+            &client,
+            &ctxt,
+            repository_url,
+            "perf-tmp",
+            rolled_up_head,
+            "merge",
+        )
+        .await
+        .map_err(|e| format!("Error merging commit into perf-tmp: {e:?}"))?;
+
+        // Force the `try-perf` branch to point to what the perf-tmp branch points to
+        update_branch(&client, &ctxt, repository_url, "try-perf", &sha)
+            .await
+            .map_err(|e| format!("Error updating the try-perf branch: {e:?}"))?;
+
+        // Wait to ensure there's enough time for GitHub to checkout these changes before they are overwritten
+        tokio::time::sleep(std::time::Duration::from_secs(15)).await
+    }
+    Ok(github::Response)
+}
+
+async fn is_rollup(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    push: &github::Push,
+) -> ServerResult<bool> {
+    macro_rules! get {
+        ($x:expr) => {
+            match $x {
+                Some(x) => x,
+                None => return Ok(false),
+            }
+        };
+    }
+    let is_bors = push.sender.login == "bors"
+        && push.committer.username == "bors"
+        && push.head_commit.message.starts_with("Auto merge of");
+
+    if !is_bors {
+        return Ok(false);
+    }
+    let captures = get!(ROLLUP_PR_NUMBER.captures(&push.head_commit.message));
+    let number = get!(get!(captures.get(0)).as_str().parse::<u64>().ok());
+
+    let issue = get_issue(client, ctxt, repository_url, number)
+        .await
+        .map_err(|e| format!("Error fetching PR #{number} {e:?}"))?;
+
+    Ok(issue.labels.iter().any(|l| l.name == "rollup"))
+}
+
 async fn handle_issue(
     ctxt: Arc<SiteCtxt>,
     issue: github::Issue,
@@ -142,7 +235,6 @@ fn extract_update_pr_for(body: &str) -> impl Iterator<Item = &str> + '_ {
 
 fn extract_rollup_merge(capture: Captures) -> Option<&str> {
     capture.get(1).map(|c| {
-        println!("{}", c.as_str());
         c.as_str()
             .trim_start_matches("https://github.com/rust-lang/rust/commit/")
     })
diff --git a/site/src/server.rs b/site/src/server.rs
index bd146c28e..fdee7e23f 100644
--- a/site/src/server.rs
+++ b/site/src/server.rs
@@ -464,7 +464,7 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
                 }
             };
             match event.as_str() {
-                "issue_comment" => Ok(to_response(
+                "issue_comment" | "pushes" => Ok(to_response(
                     request_handlers::handle_github(check!(parse_body(&body)), ctxt.clone()).await,
                     &compression,
                 )),

From 2d0b8db0e76d4d64d47812dfb8460ef1cdae6f1c Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 09:29:32 +0200
Subject: [PATCH 03/12] Address small PR nits

---
 site/src/api.rs                     |  6 ------
 site/src/github.rs                  |  7 +++++--
 site/src/request_handlers/github.rs | 10 +++++-----
 3 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/site/src/api.rs b/site/src/api.rs
index 318220704..65587550e 100644
--- a/site/src/api.rs
+++ b/site/src/api.rs
@@ -413,7 +413,6 @@ pub mod github {
     pub struct Push {
         pub r#ref: String,
         pub sender: Sender,
-        pub committer: Committer,
         pub head_commit: HeadCommit,
         pub before: String,
         pub commits: Vec<Commit>,
@@ -436,11 +435,6 @@ pub mod github {
         pub login: String,
     }
 
-    #[derive(Debug, Clone, Serialize, Deserialize)]
-    pub struct Committer {
-        pub username: String,
-    }
-
     #[derive(Debug, Clone, Serialize, Deserialize)]
     pub struct Response;
 }
diff --git a/site/src/github.rs b/site/src/github.rs
index b945f3b4e..081457b7c 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -368,7 +368,7 @@ pub async fn merge_branch(
         .basic_auth("rust-timer", Some(timer_token))
         .send()
         .await
-        .context("POST git/commits failed")?;
+        .context("PATCH /merges failed")?;
     if !response.status().is_success() {
         anyhow::bail!("{:?} != 201 CREATED", response.status());
     }
@@ -445,7 +445,10 @@ pub async fn get_issue(
         .basic_auth("rust-timer", Some(timer_token))
         .send()
         .await
-        .context("cannot get commit")?;
+        .context("cannot get issue")?;
+    if !response.status().is_success() {
+        anyhow::bail!("{:?} != 200 OK", response.status());
+    }
 
     Ok(response.json().await?)
 }
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index beacd5f37..f6355d47c 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -57,10 +57,11 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         // The second parent is the head of the PR that was rolled up. We want the second parent.
         let commit = get_commit(&client, &ctxt, repository_url, &rollup_merge)
             .await
-            .map_err(|e| format!("Error getting rollup merge commit: {e:?}"))?;
+            .map_err(|e| format!("Error getting rollup merge commit '{rollup_merge}': {e:?}"))?;
         assert!(
             commit.parents.len() == 2,
-            "What we thought was a merge commit was not a merge commit"
+            "What we thought was a merge commit was not a merge commit. sha: {}",
+            rollup_merge
         );
         let rolled_up_head = &commit.parents[1].sha;
 
@@ -106,9 +107,8 @@ async fn is_rollup(
             }
         };
     }
-    let is_bors = push.sender.login == "bors"
-        && push.committer.username == "bors"
-        && push.head_commit.message.starts_with("Auto merge of");
+    let is_bors =
+        push.sender.login == "bors" && push.head_commit.message.starts_with("Auto merge of");
 
     if !is_bors {
         return Ok(false);

From 56f8f3aac12a240acd5a1334e1902a8a9fb38b80 Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 10:04:59 +0200
Subject: [PATCH 04/12] Post mapping between PR and new try commit

---
 site/src/request_handlers/github.rs | 64 +++++++++++++++++++++++------
 1 file changed, 51 insertions(+), 13 deletions(-)

diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index f6355d47c..aac3cc1e7 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -12,6 +12,8 @@ use regex::{Captures, Regex};
 lazy_static::lazy_static! {
     static ref ROLLUP_PR_NUMBER: Regex =
         Regex::new(r#"^Auto merge of #(\d+)"#).unwrap();
+    static ref ROLLUPED_PR_NUMBER: Regex =
+        Regex::new(r#"^Rollup merge of #(\d+)"#).unwrap();
     static ref BODY_TRY_COMMIT: Regex =
         Regex::new(r#"(?:\W|^)@rust-timer\s+build\s+(\w+)(?:\W|$)(?:include=(\S+))?\s*(?:exclude=(\S+))?\s*(?:runs=(\d+))?"#).unwrap();
     static ref BODY_QUEUE: Regex =
@@ -36,11 +38,14 @@ pub async fn handle_github(
 async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<github::Response> {
     let client = reqwest::Client::new();
     let repository_url = "https://github.com/rust-lang-ci/rust";
-    if push.r#ref != "refs/heads/master"
-        || !is_rollup(&client, &ctxt, repository_url, &push).await?
-    {
+    if push.r#ref != "refs/heads/master" {
         return Ok(github::Response);
     }
+    let pr = rollup_pr(&client, &ctxt, repository_url, &push).await?;
+    let pr = match pr {
+        Some(pr) => pr,
+        None => return Ok(github::Response),
+    };
 
     let previous_master = &push.before;
     let rollup_merges = push
@@ -48,20 +53,35 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         .iter()
         .rev()
         .skip(1) // skip the head commit
-        .take_while(|c| c.message.starts_with("Rollup merge of "))
-        .map(|c| &c.sha);
+        .take_while(|c| c.message.starts_with("Rollup merge of "));
 
+    let mut prs = Vec::new();
     for rollup_merge in rollup_merges {
+        let pr_num = ROLLUPED_PR_NUMBER
+            .captures(&rollup_merge.message)
+            .and_then(|c| c.get(0))
+            .map(|m| m.as_str())
+            .ok_or_else(|| {
+                format!(
+                    "Could not get PR number from message: '{}'",
+                    rollup_merge.message
+                )
+            })?;
         // Fetch the rollup merge commit which should have two parents.
         // The first parent is in the chain of rollup merge commits all the way back to `previous_master`.
         // The second parent is the head of the PR that was rolled up. We want the second parent.
-        let commit = get_commit(&client, &ctxt, repository_url, &rollup_merge)
+        let commit = get_commit(&client, &ctxt, repository_url, &rollup_merge.sha)
             .await
-            .map_err(|e| format!("Error getting rollup merge commit '{rollup_merge}': {e:?}"))?;
+            .map_err(|e| {
+                format!(
+                    "Error getting rollup merge commit '{}': {e:?}",
+                    rollup_merge.sha
+                )
+            })?;
         assert!(
             commit.parents.len() == 2,
             "What we thought was a merge commit was not a merge commit. sha: {}",
-            rollup_merge
+            rollup_merge.sha
         );
         let rolled_up_head = &commit.parents[1].sha;
 
@@ -87,23 +107,37 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
             .await
             .map_err(|e| format!("Error updating the try-perf branch: {e:?}"))?;
 
+        prs.push((pr_num, sha));
         // Wait to ensure there's enough time for GitHub to checkout these changes before they are overwritten
         tokio::time::sleep(std::time::Duration::from_secs(15)).await
     }
+
+    // Post comment to the rollup PR with the mapping between individual PRs and the new try commits
+    let mapping = prs
+        .into_iter()
+        .fold(String::new(), |mut string, (pr, commit)| {
+            use std::fmt::Write;
+            write!(&mut string, "#{pr}: {commit}\n").unwrap();
+            string
+        });
+    let msg =
+        format!("Try perf builds for each individual rolled up PR have been enqueued:\n{mapping}");
+    post_comment(&ctxt.config, pr, msg).await;
     Ok(github::Response)
 }
 
-async fn is_rollup(
+// Gets the pr number for the associated rollup PR. Returns None if this is not a rollup PR
+async fn rollup_pr(
     client: &reqwest::Client,
     ctxt: &SiteCtxt,
     repository_url: &str,
     push: &github::Push,
-) -> ServerResult<bool> {
+) -> ServerResult<Option<u32>> {
     macro_rules! get {
         ($x:expr) => {
             match $x {
                 Some(x) => x,
-                None => return Ok(false),
+                None => return Ok(None),
             }
         };
     }
@@ -111,7 +145,7 @@ async fn is_rollup(
         push.sender.login == "bors" && push.head_commit.message.starts_with("Auto merge of");
 
     if !is_bors {
-        return Ok(false);
+        return Ok(None);
     }
     let captures = get!(ROLLUP_PR_NUMBER.captures(&push.head_commit.message));
     let number = get!(get!(captures.get(0)).as_str().parse::<u64>().ok());
@@ -120,7 +154,11 @@ async fn is_rollup(
         .await
         .map_err(|e| format!("Error fetching PR #{number} {e:?}"))?;
 
-    Ok(issue.labels.iter().any(|l| l.name == "rollup"))
+    Ok(issue
+        .labels
+        .iter()
+        .any(|l| l.name == "rollup")
+        .then(|| issue.number))
 }
 
 async fn handle_issue(

From abc99915532716fc1b0d21a1dfff9df53126e7e8 Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 10:15:24 +0200
Subject: [PATCH 05/12] Move github client

---
 site/src/github.rs                  | 352 +---------------------------
 site/src/github/client.rs           | 351 +++++++++++++++++++++++++++
 site/src/request_handlers/github.rs |  22 +-
 3 files changed, 367 insertions(+), 358 deletions(-)
 create mode 100644 site/src/github/client.rs

diff --git a/site/src/github.rs b/site/src/github.rs
index 081457b7c..c4a02867a 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -1,14 +1,16 @@
+pub mod client;
+
 use crate::api::github::Issue;
 use crate::comparison::{
     deserves_attention_icount, write_summary_table, write_summary_table_footer, ArtifactComparison,
     ArtifactComparisonSummary, Direction, Metric,
 };
-use crate::load::{Config, SiteCtxt, TryCommit};
+use crate::load::{SiteCtxt, TryCommit};
+use client::*;
 
 use anyhow::Context as _;
 use database::{ArtifactId, QueuedCommit};
-use reqwest::header::USER_AGENT;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 
 use std::collections::HashSet;
 
@@ -201,318 +203,6 @@ pub async fn branch_for_rollup(
     })
 }
 
-#[derive(serde::Serialize)]
-struct CreateRefRequest<'a> {
-    // Must start with `refs/` and have at least two slashes.
-    // e.g. `refs/heads/master`.
-    #[serde(rename = "ref")]
-    ref_: &'a str,
-    sha: &'a str,
-}
-
-pub async fn create_ref(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    ref_: &str,
-    sha: &str,
-) -> anyhow::Result<()> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/refs", repository_url);
-    let response = client
-        .post(&url)
-        .json(&CreateRefRequest { ref_, sha })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST git/refs failed")?;
-    if response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
-    }
-
-    Ok(())
-}
-
-#[derive(serde::Serialize)]
-struct CreatePrRequest<'a> {
-    title: &'a str,
-    // username:branch if cross-repo
-    head: &'a str,
-    // branch to pull into (e.g, master)
-    base: &'a str,
-    #[serde(rename = "body")]
-    description: &'a str,
-    draft: bool,
-}
-
-#[derive(Debug, serde::Deserialize)]
-pub struct CreatePrResponse {
-    pub number: u32,
-    pub html_url: String,
-    pub comments_url: String,
-}
-
-pub async fn create_pr(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    title: &str,
-    head: &str,
-    base: &str,
-    description: &str,
-    draft: bool,
-) -> anyhow::Result<CreatePrResponse> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/pulls", repository_url);
-    let response = client
-        .post(&url)
-        .json(&CreatePrRequest {
-            title,
-            head,
-            base,
-            description,
-            draft,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST pulls failed")?;
-    if response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
-    }
-
-    Ok(response.json().await.context("deserializing failed")?)
-}
-
-#[derive(serde::Serialize)]
-struct UpdateBranchRequest<'a> {
-    sha: &'a str,
-    force: bool,
-}
-
-pub async fn update_branch(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    branch: &str,
-    sha: &str,
-) -> anyhow::Result<()> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/refs/{}", repository_url, branch);
-    let commit_response = client
-        .patch(&url)
-        .json(&UpdateBranchRequest { sha, force: true })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("PATCH git/refs failed")?;
-    if commit_response.status() != reqwest::StatusCode::OK {
-        anyhow::bail!("{:?} != 200 OK", commit_response.status());
-    }
-
-    Ok(())
-}
-
-#[derive(serde::Serialize)]
-struct MergeBranchRequest<'a> {
-    base: &'a str,
-    head: &'a str,
-    commit_message: &'a str,
-}
-#[derive(serde::Deserialize)]
-struct MergeBranchResponse {
-    sha: String,
-}
-
-pub async fn merge_branch(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    branch: &str,
-    sha: &str,
-    commit_message: &str,
-) -> anyhow::Result<String> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/merges", repository_url);
-    let response = client
-        .patch(&url)
-        .json(&MergeBranchRequest {
-            base: branch,
-            head: sha,
-            commit_message,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("PATCH /merges failed")?;
-    if !response.status().is_success() {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
-    }
-
-    Ok(response.json::<MergeBranchResponse>().await?.sha)
-}
-
-#[derive(serde::Serialize)]
-struct CreateCommitRequest<'a> {
-    message: &'a str,
-    tree: &'a str,
-    parents: &'a [&'a str],
-}
-
-#[derive(serde::Deserialize)]
-struct CreateCommitResponse {
-    sha: String,
-}
-
-pub async fn create_commit(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    message: &str,
-    tree: &str,
-    parents: &[&str],
-) -> anyhow::Result<String> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/commits", repository_url);
-    let commit_response = client
-        .post(&url)
-        .json(&CreateCommitRequest {
-            message,
-            tree,
-            parents,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST git/commits failed")?;
-    if commit_response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", commit_response.status());
-    }
-
-    Ok(commit_response
-        .json::<CreateCommitResponse>()
-        .await
-        .context("deserializing failed")?
-        .sha)
-}
-
-pub async fn get_issue(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    number: u64,
-) -> anyhow::Result<Issue> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/issues/{}", repository_url, number);
-    let response = client
-        .get(&url)
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("cannot get issue")?;
-    if !response.status().is_success() {
-        anyhow::bail!("{:?} != 200 OK", response.status());
-    }
-
-    Ok(response.json().await?)
-}
-
-pub async fn get_commit(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    sha: &str,
-) -> anyhow::Result<Commit> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/commits/{}", repository_url, sha);
-    let commit_response = client
-        .get(&url)
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("cannot get commit")?;
-    let commit_response = match commit_response.text().await {
-        Ok(c) => c,
-        Err(err) => {
-            anyhow::bail!("Failed to decode response for {}: {:?}", url, err);
-        }
-    };
-    match serde_json::from_str(&commit_response) {
-        Ok(c) => Ok(c),
-        Err(e) => Err(anyhow::anyhow!(
-            "cannot deserialize commit ({}): {:?}",
-            commit_response,
-            e
-        )),
-    }
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct Commit {
-    pub sha: String,
-    pub commit: InnerCommit,
-    pub parents: Vec<CommitParent>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct InnerCommit {
-    #[serde(default)]
-    pub message: String,
-    pub tree: CommitTree,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct CommitTree {
-    pub sha: String,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct CommitParent {
-    pub sha: String,
-}
-
 pub async fn enqueue_sha(issue: Issue, ctxt: &SiteCtxt, commit: String) -> Result<(), String> {
     let client = reqwest::Client::new();
     let commit_response = get_commit(&client, ctxt, &issue.repository_url, &commit)
@@ -584,38 +274,6 @@ pub async fn parse_homu_comment(comment_body: &str) -> Option<String> {
     Some(sha)
 }
 
-pub async fn post_comment<B>(cfg: &Config, pr: u32, body: B)
-where
-    B: Into<String>,
-{
-    let body = body.into();
-    let timer_token = cfg
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let client = reqwest::Client::new();
-    let req = client
-        .post(&format!(
-            "https://api.github.com/repos/rust-lang/rust/issues/{}/comments",
-            pr
-        ))
-        .json(&PostComment {
-            body: body.to_owned(),
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token));
-
-    if let Err(e) = req.send().await {
-        eprintln!("failed to post comment: {:?}", e);
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct PostComment {
-    pub body: String,
-}
-
 /// Post messages to GitHub for all queued commits that have
 /// not yet been marked as completed.
 pub async fn post_finished(ctxt: &SiteCtxt) {
diff --git a/site/src/github/client.rs b/site/src/github/client.rs
new file mode 100644
index 000000000..ba5679259
--- /dev/null
+++ b/site/src/github/client.rs
@@ -0,0 +1,351 @@
+use anyhow::Context;
+use http::header::USER_AGENT;
+
+use crate::{
+    api::github::Issue,
+    load::{Config, SiteCtxt},
+};
+
+#[derive(serde::Serialize)]
+struct CreateRefRequest<'a> {
+    // Must start with `refs/` and have at least two slashes.
+    // e.g. `refs/heads/master`.
+    #[serde(rename = "ref")]
+    ref_: &'a str,
+    sha: &'a str,
+}
+
+pub async fn create_ref(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    ref_: &str,
+    sha: &str,
+) -> anyhow::Result<()> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/git/refs", repository_url);
+    let response = client
+        .post(&url)
+        .json(&CreateRefRequest { ref_, sha })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("POST git/refs failed")?;
+    if response.status() != reqwest::StatusCode::CREATED {
+        anyhow::bail!("{:?} != 201 CREATED", response.status());
+    }
+
+    Ok(())
+}
+
+#[derive(serde::Serialize)]
+struct CreatePrRequest<'a> {
+    title: &'a str,
+    // username:branch if cross-repo
+    head: &'a str,
+    // branch to pull into (e.g, master)
+    base: &'a str,
+    #[serde(rename = "body")]
+    description: &'a str,
+    draft: bool,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct CreatePrResponse {
+    pub number: u32,
+    pub html_url: String,
+    pub comments_url: String,
+}
+
+pub async fn create_pr(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    title: &str,
+    head: &str,
+    base: &str,
+    description: &str,
+    draft: bool,
+) -> anyhow::Result<CreatePrResponse> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/pulls", repository_url);
+    let response = client
+        .post(&url)
+        .json(&CreatePrRequest {
+            title,
+            head,
+            base,
+            description,
+            draft,
+        })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("POST pulls failed")?;
+    if response.status() != reqwest::StatusCode::CREATED {
+        anyhow::bail!("{:?} != 201 CREATED", response.status());
+    }
+
+    Ok(response.json().await.context("deserializing failed")?)
+}
+
+#[derive(serde::Serialize)]
+struct UpdateBranchRequest<'a> {
+    sha: &'a str,
+    force: bool,
+}
+
+pub async fn update_branch(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    branch: &str,
+    sha: &str,
+) -> anyhow::Result<()> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/git/refs/{}", repository_url, branch);
+    let commit_response = client
+        .patch(&url)
+        .json(&UpdateBranchRequest { sha, force: true })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("PATCH git/refs failed")?;
+    if commit_response.status() != reqwest::StatusCode::OK {
+        anyhow::bail!("{:?} != 200 OK", commit_response.status());
+    }
+
+    Ok(())
+}
+
+#[derive(serde::Serialize)]
+struct MergeBranchRequest<'a> {
+    base: &'a str,
+    head: &'a str,
+    commit_message: &'a str,
+}
+#[derive(serde::Deserialize)]
+struct MergeBranchResponse {
+    sha: String,
+}
+
+pub async fn merge_branch(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    branch: &str,
+    sha: &str,
+    commit_message: &str,
+) -> anyhow::Result<String> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/merges", repository_url);
+    let response = client
+        .patch(&url)
+        .json(&MergeBranchRequest {
+            base: branch,
+            head: sha,
+            commit_message,
+        })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("PATCH /merges failed")?;
+    if !response.status().is_success() {
+        anyhow::bail!("{:?} != 201 CREATED", response.status());
+    }
+
+    Ok(response.json::<MergeBranchResponse>().await?.sha)
+}
+
+#[derive(serde::Serialize)]
+struct CreateCommitRequest<'a> {
+    message: &'a str,
+    tree: &'a str,
+    parents: &'a [&'a str],
+}
+
+#[derive(serde::Deserialize)]
+struct CreateCommitResponse {
+    sha: String,
+}
+
+pub async fn create_commit(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    message: &str,
+    tree: &str,
+    parents: &[&str],
+) -> anyhow::Result<String> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/git/commits", repository_url);
+    let commit_response = client
+        .post(&url)
+        .json(&CreateCommitRequest {
+            message,
+            tree,
+            parents,
+        })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("POST git/commits failed")?;
+    if commit_response.status() != reqwest::StatusCode::CREATED {
+        anyhow::bail!("{:?} != 201 CREATED", commit_response.status());
+    }
+
+    Ok(commit_response
+        .json::<CreateCommitResponse>()
+        .await
+        .context("deserializing failed")?
+        .sha)
+}
+
+pub async fn get_issue(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    number: u64,
+) -> anyhow::Result<Issue> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/issues/{}", repository_url, number);
+    let response = client
+        .get(&url)
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("cannot get issue")?;
+    if !response.status().is_success() {
+        anyhow::bail!("{:?} != 200 OK", response.status());
+    }
+
+    Ok(response.json().await?)
+}
+
+pub async fn get_commit(
+    client: &reqwest::Client,
+    ctxt: &SiteCtxt,
+    repository_url: &str,
+    sha: &str,
+) -> anyhow::Result<Commit> {
+    let timer_token = ctxt
+        .config
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let url = format!("{}/commits/{}", repository_url, sha);
+    let commit_response = client
+        .get(&url)
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token))
+        .send()
+        .await
+        .context("cannot get commit")?;
+    let commit_response = match commit_response.text().await {
+        Ok(c) => c,
+        Err(err) => {
+            anyhow::bail!("Failed to decode response for {}: {:?}", url, err);
+        }
+    };
+    match serde_json::from_str(&commit_response) {
+        Ok(c) => Ok(c),
+        Err(e) => Err(anyhow::anyhow!(
+            "cannot deserialize commit ({}): {:?}",
+            commit_response,
+            e
+        )),
+    }
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct Commit {
+    pub sha: String,
+    pub commit: InnerCommit,
+    pub parents: Vec<CommitParent>,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct InnerCommit {
+    #[serde(default)]
+    pub message: String,
+    pub tree: CommitTree,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct CommitTree {
+    pub sha: String,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct CommitParent {
+    pub sha: String,
+}
+
+pub async fn post_comment<B>(cfg: &Config, pr: u32, body: B)
+where
+    B: Into<String>,
+{
+    let body = body.into();
+    let timer_token = cfg
+        .keys
+        .github_api_token
+        .clone()
+        .expect("needs github API token");
+    let client = reqwest::Client::new();
+    let req = client
+        .post(&format!(
+            "https://api.github.com/repos/rust-lang/rust/issues/{}/comments",
+            pr
+        ))
+        .json(&PostComment {
+            body: body.to_owned(),
+        })
+        .header(USER_AGENT, "perf-rust-lang-org-server")
+        .basic_auth("rust-timer", Some(timer_token));
+
+    if let Err(e) = req.send().await {
+        eprintln!("failed to post comment: {:?}", e);
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct PostComment {
+    pub body: String,
+}
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index aac3cc1e7..453097178 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -1,7 +1,7 @@
 use crate::api::{github, ServerResult};
 use crate::github::{
-    branch_for_rollup, enqueue_sha, get_authorized_users, get_commit, get_issue, merge_branch,
-    parse_homu_comment, post_comment, pr_and_try_for_rollup, update_branch,
+    branch_for_rollup, client, enqueue_sha, get_authorized_users, parse_homu_comment,
+    pr_and_try_for_rollup,
 };
 use crate::load::SiteCtxt;
 
@@ -70,7 +70,7 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         // Fetch the rollup merge commit which should have two parents.
         // The first parent is in the chain of rollup merge commits all the way back to `previous_master`.
         // The second parent is the head of the PR that was rolled up. We want the second parent.
-        let commit = get_commit(&client, &ctxt, repository_url, &rollup_merge.sha)
+        let commit = client::get_commit(&client, &ctxt, repository_url, &rollup_merge.sha)
             .await
             .map_err(|e| {
                 format!(
@@ -86,12 +86,12 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         let rolled_up_head = &commit.parents[1].sha;
 
         // Reset perf-tmp to the previous master
-        update_branch(&client, &ctxt, repository_url, "perf-tmp", previous_master)
+        client::update_branch(&client, &ctxt, repository_url, "perf-tmp", previous_master)
             .await
             .map_err(|e| format!("Error updating perf-tmp with previous master: {e:?}"))?;
 
         // Merge in the rolled up PR's head commit into the previous master
-        let sha = merge_branch(
+        let sha = client::merge_branch(
             &client,
             &ctxt,
             repository_url,
@@ -103,7 +103,7 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         .map_err(|e| format!("Error merging commit into perf-tmp: {e:?}"))?;
 
         // Force the `try-perf` branch to point to what the perf-tmp branch points to
-        update_branch(&client, &ctxt, repository_url, "try-perf", &sha)
+        client::update_branch(&client, &ctxt, repository_url, "try-perf", &sha)
             .await
             .map_err(|e| format!("Error updating the try-perf branch: {e:?}"))?;
 
@@ -122,7 +122,7 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         });
     let msg =
         format!("Try perf builds for each individual rolled up PR have been enqueued:\n{mapping}");
-    post_comment(&ctxt.config, pr, msg).await;
+    client::post_comment(&ctxt.config, pr, msg).await;
     Ok(github::Response)
 }
 
@@ -150,7 +150,7 @@ async fn rollup_pr(
     let captures = get!(ROLLUP_PR_NUMBER.captures(&push.head_commit.message));
     let number = get!(get!(captures.get(0)).as_str().parse::<u64>().ok());
 
-    let issue = get_issue(client, ctxt, repository_url, number)
+    let issue = client::get_issue(client, ctxt, repository_url, number)
         .await
         .map_err(|e| format!("Error fetching PR #{number} {e:?}"))?;
 
@@ -188,7 +188,7 @@ async fn handle_rust_timer(
     if comment.author_association != github::Association::Owner
         && !get_authorized_users().await?.contains(&comment.user.id)
     {
-        post_comment(
+        client::post_comment(
             &ctxt.config,
             issue.number,
             "Insufficient permissions to issue commands to rust-timer.",
@@ -205,7 +205,7 @@ async fn handle_rust_timer(
             let conn = ctxt.conn().await;
             conn.queue_pr(issue.number, include, exclude, runs).await;
         }
-        post_comment(
+        client::post_comment(
             &ctxt.config,
             issue.number,
             "Awaiting bors try build completion.
@@ -249,7 +249,7 @@ async fn handle_rust_timer(
         let branch = branch_for_rollup(&client, &ctxt, &issue.repository_url, rollup_merge)
             .await
             .map_err(|e| e.to_string())?;
-        post_comment(
+        client::post_comment(
             &ctxt.config,
             issue.number,
             &format!("Master base SHA: {}", branch.master_base_sha),

From ee3ca116be712be82738bed7c2082e2174eb6e4e Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 10:58:28 +0200
Subject: [PATCH 06/12] Make a client type

---
 site/src/github.rs                  | 139 ++++----
 site/src/github/client.rs           | 533 +++++++++++++---------------
 site/src/request_handlers/github.rs |  97 +++--
 3 files changed, 348 insertions(+), 421 deletions(-)

diff --git a/site/src/github.rs b/site/src/github.rs
index c4a02867a..81c25feec 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -6,7 +6,6 @@ use crate::comparison::{
     ArtifactComparisonSummary, Direction, Metric,
 };
 use crate::load::{SiteCtxt, TryCommit};
-use client::*;
 
 use anyhow::Context as _;
 use database::{ArtifactId, QueuedCommit};
@@ -36,40 +35,38 @@ pub async fn get_authorized_users() -> Result<Vec<usize>, String> {
 
 // Returns the PR number
 pub async fn pr_and_try_for_rollup(
-    client: &reqwest::Client,
     ctxt: Arc<SiteCtxt>,
     repository_url: &str,
     rollup_merge_sha: &str,
     origin_url: &str,
 ) -> anyhow::Result<u32> {
+    let client = client::Client::from_ctxt(&ctxt, repository_url.to_owned());
     log::trace!(
         "creating PR for {:?} {:?}",
         repository_url,
         rollup_merge_sha
     );
-    let branch = branch_for_rollup(client, &ctxt, repository_url, rollup_merge_sha).await?;
+    let branch = branch_for_rollup(&ctxt, repository_url, rollup_merge_sha).await?;
 
-    let pr = create_pr(
-        client,
-        &ctxt,
-        repository_url,
-        &format!(
-            "[DO NOT MERGE] perf-test for #{}",
-            branch.rolled_up_pr_number
-        ),
-        &format!("rust-timer:{}", branch.name),
-        "master",
-        &format!(
-            "This is an automatically generated pull request (from [here]({})) to \
+    let pr = client
+        .create_pr(
+            &format!(
+                "[DO NOT MERGE] perf-test for #{}",
+                branch.rolled_up_pr_number
+            ),
+            &format!("rust-timer:{}", branch.name),
+            "master",
+            &format!(
+                "This is an automatically generated pull request (from [here]({})) to \
             run perf tests for #{} which merged in a rollup.
 
 r? @ghost",
-            origin_url, branch.rolled_up_pr_number
-        ),
-        true,
-    )
-    .await
-    .context("Created PR")?;
+                origin_url, branch.rolled_up_pr_number
+            ),
+            true,
+        )
+        .await
+        .context("Created PR")?;
 
     let pr_number = pr.number;
     let rollup_merge_sha = rollup_merge_sha.to_owned();
@@ -84,11 +81,11 @@ r? @ghost",
         // Eventually we'll want to handle this automatically, but that's a ways
         // off: we'd need to store the state in the database and handle the try
         // build starting and generally that's a lot of work for not too much gain.
-        post_comment(
-            &ctxt.config,
-            pr.number,
-            &format!(
-                "@bors try @rust-timer queue
+        client
+            .post_comment(
+                pr.number,
+                &format!(
+                    "@bors try @rust-timer queue
 
 The try commit's (master) parent should be {master}. If it isn't, \
 then please:
@@ -99,11 +96,11 @@ then please:
 
 You do not need to reinvoke the queue command as long as the perf \
 build hasn't yet started.",
-                master = branch.master_base_sha,
-                merge = rollup_merge_sha,
-            ),
-        )
-        .await;
+                    master = branch.master_base_sha,
+                    merge = rollup_merge_sha,
+                ),
+            )
+            .await;
     });
 
     Ok(pr_number)
@@ -116,12 +113,15 @@ pub struct RollupBranch {
 }
 
 pub async fn branch_for_rollup(
-    client: &reqwest::Client,
     ctxt: &SiteCtxt,
     repository_url: &str,
     rollup_merge_sha: &str,
 ) -> anyhow::Result<RollupBranch> {
-    let rollup_merge = get_commit(&client, &ctxt, repository_url, rollup_merge_sha)
+    let client = client::Client::from_ctxt(ctxt, repository_url.to_owned());
+    let timer = "https://api.github.com/repos/rust-timer/rust";
+    let timer_client = client::Client::from_ctxt(ctxt, timer.to_owned());
+    let rollup_merge = client
+        .get_commit(rollup_merge_sha)
         .await
         .context("got rollup merge")?;
 
@@ -132,40 +132,38 @@ pub async fn branch_for_rollup(
             break;
         }
         assert_eq!(current.parents.len(), 2);
-        current = get_commit(&client, &ctxt, repository_url, &current.parents[0].sha)
+        current = client
+            .get_commit(&current.parents[0].sha)
             .await
             .context("success master get")?;
     }
     let old_master_commit = current;
 
-    let current_master_commit = get_commit(&client, &ctxt, repository_url, "master")
+    let current_master_commit = client
+        .get_commit("master")
         .await
         .context("success master get")?;
 
-    let revert_sha = create_commit(
-        &client,
-        &ctxt,
-        "https://api.github.com/repos/rust-timer/rust",
-        &format!("Revert to {}", old_master_commit.sha),
-        &old_master_commit.commit.tree.sha,
-        &[&current_master_commit.sha],
-    )
-    .await
-    .context("create revert")?;
-
-    let merge_sha = create_commit(
-        &client,
-        &ctxt,
-        "https://api.github.com/repos/rust-timer/rust",
-        &format!(
-            "rust-timer simulated merge of {}\n\nOriginal message:\n{}",
-            rollup_merge.sha, rollup_merge.commit.message
-        ),
-        &rollup_merge.commit.tree.sha,
-        &[&revert_sha],
-    )
-    .await
-    .context("create merge commit")?;
+    let revert_sha = timer_client
+        .create_commit(
+            &format!("Revert to {}", old_master_commit.sha),
+            &old_master_commit.commit.tree.sha,
+            &[&current_master_commit.sha],
+        )
+        .await
+        .context("create revert")?;
+
+    let merge_sha = timer_client
+        .create_commit(
+            &format!(
+                "rust-timer simulated merge of {}\n\nOriginal message:\n{}",
+                rollup_merge.sha, rollup_merge.commit.message
+            ),
+            &rollup_merge.commit.tree.sha,
+            &[&revert_sha],
+        )
+        .await
+        .context("create merge commit")?;
 
     let rolled_up_pr_number = if let Some(stripped) = rollup_merge
         .commit
@@ -186,15 +184,10 @@ pub async fn branch_for_rollup(
     };
 
     let branch = format!("try-for-{}", rolled_up_pr_number);
-    create_ref(
-        &client,
-        &ctxt,
-        "https://api.github.com/repos/rust-timer/rust",
-        &format!("refs/heads/{}", branch),
-        &merge_sha,
-    )
-    .await
-    .context("created branch")?;
+    timer_client
+        .create_ref(&format!("refs/heads/{}", branch), &merge_sha)
+        .await
+        .context("created branch")?;
 
     Ok(RollupBranch {
         rolled_up_pr_number,
@@ -204,8 +197,9 @@ pub async fn branch_for_rollup(
 }
 
 pub async fn enqueue_sha(issue: Issue, ctxt: &SiteCtxt, commit: String) -> Result<(), String> {
-    let client = reqwest::Client::new();
-    let commit_response = get_commit(&client, ctxt, &issue.repository_url, &commit)
+    let client = client::Client::from_ctxt(ctxt, issue.repository_url.clone());
+    let commit_response = client
+        .get_commit(&commit)
         .await
         .map_err(|e| e.to_string())?;
     if commit_response.parents.len() != 2 {
@@ -237,7 +231,7 @@ pub async fn enqueue_sha(issue: Issue, ctxt: &SiteCtxt, commit: String) -> Resul
             commit_response.parents[0].sha,
             try_commit.comparison_url(),
         );
-        post_comment(&ctxt.config, issue.number, msg).await;
+        client.post_comment(issue.number, msg).await;
     }
     Ok(())
 }
@@ -331,13 +325,14 @@ pub async fn post_finished(ctxt: &SiteCtxt) {
 ///
 /// `is_master_commit` is used to differentiate messages for try runs and post-merge runs.
 async fn post_comparison_comment(ctxt: &SiteCtxt, commit: QueuedCommit, is_master_commit: bool) {
+    let client = client::Client::from_ctxt(ctxt, "https://github.com/rust-lang/rust".to_owned());
     let pr = commit.pr;
     let body = match summarize_run(ctxt, commit, is_master_commit).await {
         Ok(message) => message,
         Err(error) => error,
     };
 
-    post_comment(&ctxt.config, pr, body).await;
+    client.post_comment(pr, body).await;
 }
 
 fn make_comparison_url(commit: &QueuedCommit, stat: Metric) -> String {
diff --git a/site/src/github/client.rs b/site/src/github/client.rs
index ba5679259..217c99c24 100644
--- a/site/src/github/client.rs
+++ b/site/src/github/client.rs
@@ -1,299 +1,272 @@
 use anyhow::Context;
 use http::header::USER_AGENT;
 
-use crate::{
-    api::github::Issue,
-    load::{Config, SiteCtxt},
-};
+use crate::{api::github::Issue, load::SiteCtxt};
 
-#[derive(serde::Serialize)]
-struct CreateRefRequest<'a> {
-    // Must start with `refs/` and have at least two slashes.
-    // e.g. `refs/heads/master`.
-    #[serde(rename = "ref")]
-    ref_: &'a str,
-    sha: &'a str,
+/// A client for interacting with the GitHub API
+pub struct Client {
+    repository_url: String,
+    token: String,
+    inner: reqwest::Client,
 }
 
-pub async fn create_ref(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    ref_: &str,
-    sha: &str,
-) -> anyhow::Result<()> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/refs", repository_url);
-    let response = client
-        .post(&url)
-        .json(&CreateRefRequest { ref_, sha })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST git/refs failed")?;
-    if response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
+impl Client {
+    /// Create a new client from a URL and token (useful for testing)
+    pub fn new(repository_url: String, token: String) -> Self {
+        Self {
+            repository_url,
+            token,
+            inner: reqwest::Client::new(),
+        }
     }
 
-    Ok(())
-}
-
-#[derive(serde::Serialize)]
-struct CreatePrRequest<'a> {
-    title: &'a str,
-    // username:branch if cross-repo
-    head: &'a str,
-    // branch to pull into (e.g, master)
-    base: &'a str,
-    #[serde(rename = "body")]
-    description: &'a str,
-    draft: bool,
-}
+    /// Create a client from a `SiteCtxt` and a URL
+    pub fn from_ctxt(ctxt: &SiteCtxt, repository_url: String) -> Self {
+        let token = ctxt
+            .config
+            .keys
+            .github_api_token
+            .clone()
+            .expect("needs github API token");
+        Self::new(repository_url, token)
+    }
 
-#[derive(Debug, serde::Deserialize)]
-pub struct CreatePrResponse {
-    pub number: u32,
-    pub html_url: String,
-    pub comments_url: String,
-}
+    pub async fn create_ref(&self, ref_: &str, sha: &str) -> anyhow::Result<()> {
+        #[derive(serde::Serialize)]
+        struct CreateRefRequest<'a> {
+            // Must start with `refs/` and have at least two slashes.
+            // e.g. `refs/heads/master`.
+            #[serde(rename = "ref")]
+            ref_: &'a str,
+            sha: &'a str,
+        }
+        let url = format!("{}/git/refs", self.repository_url);
+        let response = self
+            .inner
+            .post(&url)
+            .json(&CreateRefRequest { ref_, sha })
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+            .context("POST git/refs failed")?;
+        if response.status() != reqwest::StatusCode::CREATED {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
+        }
 
-pub async fn create_pr(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    title: &str,
-    head: &str,
-    base: &str,
-    description: &str,
-    draft: bool,
-) -> anyhow::Result<CreatePrResponse> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/pulls", repository_url);
-    let response = client
-        .post(&url)
-        .json(&CreatePrRequest {
-            title,
-            head,
-            base,
-            description,
-            draft,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST pulls failed")?;
-    if response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
+        Ok(())
     }
 
-    Ok(response.json().await.context("deserializing failed")?)
-}
+    pub async fn create_pr(
+        &self,
+        title: &str,
+        head: &str,
+        base: &str,
+        description: &str,
+        draft: bool,
+    ) -> anyhow::Result<CreatePrResponse> {
+        #[derive(serde::Serialize)]
+        struct CreatePrRequest<'a> {
+            title: &'a str,
+            // username:branch if cross-repo
+            head: &'a str,
+            // branch to pull into (e.g, master)
+            base: &'a str,
+            #[serde(rename = "body")]
+            description: &'a str,
+            draft: bool,
+        }
 
-#[derive(serde::Serialize)]
-struct UpdateBranchRequest<'a> {
-    sha: &'a str,
-    force: bool,
-}
+        let url = format!("{}/pulls", self.repository_url);
+        let response = self
+            .inner
+            .post(&url)
+            .json(&CreatePrRequest {
+                title,
+                head,
+                base,
+                description,
+                draft,
+            })
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+            .context("POST pulls failed")?;
+        if response.status() != reqwest::StatusCode::CREATED {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
+        }
 
-pub async fn update_branch(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    branch: &str,
-    sha: &str,
-) -> anyhow::Result<()> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/refs/{}", repository_url, branch);
-    let commit_response = client
-        .patch(&url)
-        .json(&UpdateBranchRequest { sha, force: true })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("PATCH git/refs failed")?;
-    if commit_response.status() != reqwest::StatusCode::OK {
-        anyhow::bail!("{:?} != 200 OK", commit_response.status());
+        Ok(response.json().await.context("deserializing failed")?)
     }
 
-    Ok(())
-}
-
-#[derive(serde::Serialize)]
-struct MergeBranchRequest<'a> {
-    base: &'a str,
-    head: &'a str,
-    commit_message: &'a str,
-}
-#[derive(serde::Deserialize)]
-struct MergeBranchResponse {
-    sha: String,
-}
+    pub async fn update_branch(&self, branch: &str, sha: &str) -> anyhow::Result<()> {
+        #[derive(serde::Serialize)]
+        struct UpdateBranchRequest<'a> {
+            sha: &'a str,
+            force: bool,
+        }
+        let url = format!("{}/git/refs/{}", self.repository_url, branch);
+        let commit_response = self
+            .inner
+            .patch(&url)
+            .json(&UpdateBranchRequest { sha, force: true })
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+            .context("PATCH git/refs failed")?;
+        if commit_response.status() != reqwest::StatusCode::OK {
+            anyhow::bail!("{:?} != 200 OK", commit_response.status());
+        }
 
-pub async fn merge_branch(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    branch: &str,
-    sha: &str,
-    commit_message: &str,
-) -> anyhow::Result<String> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/merges", repository_url);
-    let response = client
-        .patch(&url)
-        .json(&MergeBranchRequest {
-            base: branch,
-            head: sha,
-            commit_message,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("PATCH /merges failed")?;
-    if !response.status().is_success() {
-        anyhow::bail!("{:?} != 201 CREATED", response.status());
+        Ok(())
     }
 
-    Ok(response.json::<MergeBranchResponse>().await?.sha)
-}
+    pub async fn merge_branch(
+        &self,
+        branch: &str,
+        sha: &str,
+        commit_message: &str,
+    ) -> anyhow::Result<String> {
+        #[derive(serde::Serialize)]
+        struct MergeBranchRequest<'a> {
+            base: &'a str,
+            head: &'a str,
+            commit_message: &'a str,
+        }
+        let url = format!("{}/merges", self.repository_url);
+        let response = self
+            .inner
+            .patch(&url)
+            .json(&MergeBranchRequest {
+                base: branch,
+                head: sha,
+                commit_message,
+            })
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+            .context("PATCH /merges failed")?;
+        if !response.status().is_success() {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
+        }
 
-#[derive(serde::Serialize)]
-struct CreateCommitRequest<'a> {
-    message: &'a str,
-    tree: &'a str,
-    parents: &'a [&'a str],
-}
+        Ok(response.json::<MergeBranchResponse>().await?.sha)
+    }
 
-#[derive(serde::Deserialize)]
-struct CreateCommitResponse {
-    sha: String,
-}
+    pub async fn create_commit(
+        &self,
+        message: &str,
+        tree: &str,
+        parents: &[&str],
+    ) -> anyhow::Result<String> {
+        #[derive(serde::Serialize)]
+        struct CreateCommitRequest<'a> {
+            message: &'a str,
+            tree: &'a str,
+            parents: &'a [&'a str],
+        }
+        let url = format!("{}/git/commits", self.repository_url);
+        let commit_response = self
+            .inner
+            .post(&url)
+            .json(&CreateCommitRequest {
+                message,
+                tree,
+                parents,
+            })
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+            .context("POST git/commits failed")?;
+        if commit_response.status() != reqwest::StatusCode::CREATED {
+            anyhow::bail!("{:?} != 201 CREATED", commit_response.status());
+        }
 
-pub async fn create_commit(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    message: &str,
-    tree: &str,
-    parents: &[&str],
-) -> anyhow::Result<String> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/git/commits", repository_url);
-    let commit_response = client
-        .post(&url)
-        .json(&CreateCommitRequest {
-            message,
-            tree,
-            parents,
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("POST git/commits failed")?;
-    if commit_response.status() != reqwest::StatusCode::CREATED {
-        anyhow::bail!("{:?} != 201 CREATED", commit_response.status());
+        Ok(commit_response
+            .json::<CreateCommitResponse>()
+            .await
+            .context("deserializing failed")?
+            .sha)
     }
 
-    Ok(commit_response
-        .json::<CreateCommitResponse>()
-        .await
-        .context("deserializing failed")?
-        .sha)
-}
+    pub async fn get_issue(&self, number: u64) -> anyhow::Result<Issue> {
+        let url = format!("{}/issues/{}", self.repository_url, number);
+        let response = self
+            .inner
+            .get(&url)
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+            .context("cannot get issue")?;
+        if !response.status().is_success() {
+            anyhow::bail!("{:?} != 200 OK", response.status());
+        }
 
-pub async fn get_issue(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    number: u64,
-) -> anyhow::Result<Issue> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/issues/{}", repository_url, number);
-    let response = client
-        .get(&url)
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("cannot get issue")?;
-    if !response.status().is_success() {
-        anyhow::bail!("{:?} != 200 OK", response.status());
+        Ok(response.json().await?)
     }
 
-    Ok(response.json().await?)
-}
+    pub async fn get_commit(&self, sha: &str) -> anyhow::Result<Commit> {
+        let url = format!("{}/commits/{}", self.repository_url, sha);
+        let commit_response = self
+            .inner
+            .get(&url)
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+            .context("cannot get commit")?;
+        commit_response
+            .json()
+            .await
+            .map_err(|e| anyhow::anyhow!("cannot deserialize commit: {:?}", e))
+    }
 
-pub async fn get_commit(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    sha: &str,
-) -> anyhow::Result<Commit> {
-    let timer_token = ctxt
-        .config
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let url = format!("{}/commits/{}", repository_url, sha);
-    let commit_response = client
-        .get(&url)
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token))
-        .send()
-        .await
-        .context("cannot get commit")?;
-    let commit_response = match commit_response.text().await {
-        Ok(c) => c,
-        Err(err) => {
-            anyhow::bail!("Failed to decode response for {}: {:?}", url, err);
+    pub async fn post_comment<B>(&self, pr: u32, body: B)
+    where
+        B: Into<String>,
+    {
+        #[derive(Debug, Clone, serde::Serialize)]
+        pub struct PostComment {
+            pub body: String,
+        }
+        let body = body.into();
+        let client = reqwest::Client::new();
+        let req = client
+            .post(&format!("{}/issues/{}/comments", self.repository_url, pr))
+            .json(&PostComment {
+                body: body.to_owned(),
+            })
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token));
+
+        if let Err(e) = req.send().await {
+            eprintln!("failed to post comment: {:?}", e);
         }
-    };
-    match serde_json::from_str(&commit_response) {
-        Ok(c) => Ok(c),
-        Err(e) => Err(anyhow::anyhow!(
-            "cannot deserialize commit ({}): {:?}",
-            commit_response,
-            e
-        )),
     }
 }
 
+#[derive(Debug, serde::Deserialize)]
+pub struct CreatePrResponse {
+    pub number: u32,
+    pub html_url: String,
+    pub comments_url: String,
+}
+
+#[derive(serde::Deserialize)]
+struct MergeBranchResponse {
+    sha: String,
+}
+
+#[derive(serde::Deserialize)]
+struct CreateCommitResponse {
+    sha: String,
+}
+
 #[derive(Debug, Clone, serde::Deserialize)]
 pub struct Commit {
     pub sha: String,
@@ -317,35 +290,3 @@ pub struct CommitTree {
 pub struct CommitParent {
     pub sha: String,
 }
-
-pub async fn post_comment<B>(cfg: &Config, pr: u32, body: B)
-where
-    B: Into<String>,
-{
-    let body = body.into();
-    let timer_token = cfg
-        .keys
-        .github_api_token
-        .clone()
-        .expect("needs github API token");
-    let client = reqwest::Client::new();
-    let req = client
-        .post(&format!(
-            "https://api.github.com/repos/rust-lang/rust/issues/{}/comments",
-            pr
-        ))
-        .json(&PostComment {
-            body: body.to_owned(),
-        })
-        .header(USER_AGENT, "perf-rust-lang-org-server")
-        .basic_auth("rust-timer", Some(timer_token));
-
-    if let Err(e) = req.send().await {
-        eprintln!("failed to post comment: {:?}", e);
-    }
-}
-
-#[derive(Debug, Clone, serde::Serialize)]
-pub struct PostComment {
-    pub body: String,
-}
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index 453097178..f3aaea01b 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -36,12 +36,14 @@ pub async fn handle_github(
 }
 
 async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<github::Response> {
-    let client = reqwest::Client::new();
-    let repository_url = "https://github.com/rust-lang-ci/rust";
+    let ci_client =
+        client::Client::from_ctxt(&ctxt, "https://github.com/rust-lang-ci/rust".to_owned());
+    let main_repo_client =
+        client::Client::from_ctxt(&ctxt, "https://github.com/rust-lang/rust".to_owned());
     if push.r#ref != "refs/heads/master" {
         return Ok(github::Response);
     }
-    let pr = rollup_pr(&client, &ctxt, repository_url, &push).await?;
+    let pr = rollup_pr(&ci_client, &push).await?;
     let pr = match pr {
         Some(pr) => pr,
         None => return Ok(github::Response),
@@ -70,14 +72,12 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         // Fetch the rollup merge commit which should have two parents.
         // The first parent is in the chain of rollup merge commits all the way back to `previous_master`.
         // The second parent is the head of the PR that was rolled up. We want the second parent.
-        let commit = client::get_commit(&client, &ctxt, repository_url, &rollup_merge.sha)
-            .await
-            .map_err(|e| {
-                format!(
-                    "Error getting rollup merge commit '{}': {e:?}",
-                    rollup_merge.sha
-                )
-            })?;
+        let commit = ci_client.get_commit(&rollup_merge.sha).await.map_err(|e| {
+            format!(
+                "Error getting rollup merge commit '{}': {e:?}",
+                rollup_merge.sha
+            )
+        })?;
         assert!(
             commit.parents.len() == 2,
             "What we thought was a merge commit was not a merge commit. sha: {}",
@@ -86,24 +86,20 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         let rolled_up_head = &commit.parents[1].sha;
 
         // Reset perf-tmp to the previous master
-        client::update_branch(&client, &ctxt, repository_url, "perf-tmp", previous_master)
+        ci_client
+            .update_branch("perf-tmp", previous_master)
             .await
             .map_err(|e| format!("Error updating perf-tmp with previous master: {e:?}"))?;
 
         // Merge in the rolled up PR's head commit into the previous master
-        let sha = client::merge_branch(
-            &client,
-            &ctxt,
-            repository_url,
-            "perf-tmp",
-            rolled_up_head,
-            "merge",
-        )
-        .await
-        .map_err(|e| format!("Error merging commit into perf-tmp: {e:?}"))?;
+        let sha = ci_client
+            .merge_branch("perf-tmp", rolled_up_head, "merge")
+            .await
+            .map_err(|e| format!("Error merging commit into perf-tmp: {e:?}"))?;
 
         // Force the `try-perf` branch to point to what the perf-tmp branch points to
-        client::update_branch(&client, &ctxt, repository_url, "try-perf", &sha)
+        ci_client
+            .update_branch("try-perf", &sha)
             .await
             .map_err(|e| format!("Error updating the try-perf branch: {e:?}"))?;
 
@@ -122,17 +118,12 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         });
     let msg =
         format!("Try perf builds for each individual rolled up PR have been enqueued:\n{mapping}");
-    client::post_comment(&ctxt.config, pr, msg).await;
+    main_repo_client.post_comment(pr, msg).await;
     Ok(github::Response)
 }
 
 // Gets the pr number for the associated rollup PR. Returns None if this is not a rollup PR
-async fn rollup_pr(
-    client: &reqwest::Client,
-    ctxt: &SiteCtxt,
-    repository_url: &str,
-    push: &github::Push,
-) -> ServerResult<Option<u32>> {
+async fn rollup_pr(client: &client::Client, push: &github::Push) -> ServerResult<Option<u32>> {
     macro_rules! get {
         ($x:expr) => {
             match $x {
@@ -150,7 +141,8 @@ async fn rollup_pr(
     let captures = get!(ROLLUP_PR_NUMBER.captures(&push.head_commit.message));
     let number = get!(get!(captures.get(0)).as_str().parse::<u64>().ok());
 
-    let issue = client::get_issue(client, ctxt, repository_url, number)
+    let issue = client
+        .get_issue(number)
         .await
         .map_err(|e| format!("Error fetching PR #{number} {e:?}"))?;
 
@@ -185,15 +177,17 @@ async fn handle_rust_timer(
     comment: github::Comment,
     issue: github::Issue,
 ) -> ServerResult<github::Response> {
+    let main_repo_client =
+        client::Client::from_ctxt(&ctxt, "https://github.com/rust-lang/rust".to_owned());
     if comment.author_association != github::Association::Owner
         && !get_authorized_users().await?.contains(&comment.user.id)
     {
-        client::post_comment(
-            &ctxt.config,
-            issue.number,
-            "Insufficient permissions to issue commands to rust-timer.",
-        )
-        .await;
+        main_repo_client
+            .post_comment(
+                issue.number,
+                "Insufficient permissions to issue commands to rust-timer.",
+            )
+            .await;
         return Ok(github::Response);
     }
 
@@ -205,14 +199,14 @@ async fn handle_rust_timer(
             let conn = ctxt.conn().await;
             conn.queue_pr(issue.number, include, exclude, runs).await;
         }
-        client::post_comment(
-            &ctxt.config,
-            issue.number,
-            "Awaiting bors try build completion.
+        main_repo_client
+            .post_comment(
+                issue.number,
+                "Awaiting bors try build completion.
 
 @rustbot label: +S-waiting-on-perf",
-        )
-        .await;
+            )
+            .await;
         return Ok(github::Response);
     }
     if let Some(captures) = BODY_TRY_COMMIT.captures(&comment.body) {
@@ -230,9 +224,7 @@ async fn handle_rust_timer(
         }
     }
     for rollup_merge in extract_make_pr_for(&comment.body) {
-        let client = reqwest::Client::new();
         pr_and_try_for_rollup(
-            &client,
             ctxt.clone(),
             &issue.repository_url,
             &rollup_merge,
@@ -245,16 +237,15 @@ async fn handle_rust_timer(
         // This just creates or updates the branch for this merge commit.
         // Intended for resolving the race condition of master merging in
         // between us updating the commit and merging things.
-        let client = reqwest::Client::new();
-        let branch = branch_for_rollup(&client, &ctxt, &issue.repository_url, rollup_merge)
+        let branch = branch_for_rollup(&ctxt, &issue.repository_url, rollup_merge)
             .await
             .map_err(|e| e.to_string())?;
-        client::post_comment(
-            &ctxt.config,
-            issue.number,
-            &format!("Master base SHA: {}", branch.master_base_sha),
-        )
-        .await;
+        main_repo_client
+            .post_comment(
+                issue.number,
+                &format!("Master base SHA: {}", branch.master_base_sha),
+            )
+            .await;
     }
     Ok(github::Response)
 }

From 205d2138d14d2fd2e5692a791cb9659fe92ca784 Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 11:37:16 +0200
Subject: [PATCH 07/12] Move main logic for enqueuing to its own function

---
 site/src/github.rs                  | 53 +++++++++++++++++-
 site/src/request_handlers/github.rs | 84 +++++++++--------------------
 2 files changed, 76 insertions(+), 61 deletions(-)

diff --git a/site/src/github.rs b/site/src/github.rs
index 81c25feec..92ebebc8c 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -1,6 +1,6 @@
 pub mod client;
 
-use crate::api::github::Issue;
+use crate::api::github::{Commit, Issue};
 use crate::comparison::{
     deserves_attention_icount, write_summary_table, write_summary_table_footer, ArtifactComparison,
     ArtifactComparisonSummary, Direction, Metric,
@@ -33,6 +33,57 @@ pub async fn get_authorized_users() -> Result<Vec<usize>, String> {
         .map(|perms| perms.github_ids)
 }
 
+/// Enqueues try builds on the try-perf branch for every rollup merge in `rollup_merges`.
+/// Returns a mapping between the rollup merge commit and the try build sha.
+pub async fn enqueue_unrolled_try_builds<'a>(
+    client: client::Client,
+    rollup_merges: impl Iterator<Item = &'a Commit>,
+    previous_master: &str,
+) -> Result<Vec<(&'a Commit, String)>, String> {
+    let mut mapping = Vec::new();
+    for rollup_merge in rollup_merges {
+        // Fetch the rollup merge commit which should have two parents.
+        // The first parent is in the chain of rollup merge commits all the way back to `previous_master`.
+        // The second parent is the head of the PR that was rolled up. We want the second parent.
+        let commit = client.get_commit(&rollup_merge.sha).await.map_err(|e| {
+            format!(
+                "Error getting rollup merge commit '{}': {e:?}",
+                rollup_merge.sha
+            )
+        })?;
+        assert!(
+            commit.parents.len() == 2,
+            "What we thought was a merge commit was not a merge commit. sha: {}",
+            rollup_merge.sha
+        );
+        let rolled_up_head = &commit.parents[1].sha;
+
+        // Reset perf-tmp to the previous master
+        client
+            .update_branch("perf-tmp", previous_master)
+            .await
+            .map_err(|e| format!("Error updating perf-tmp with previous master: {e:?}"))?;
+
+        // Merge in the rolled up PR's head commit into the previous master
+        let sha = client
+            .merge_branch("perf-tmp", rolled_up_head, "merge")
+            .await
+            .map_err(|e| format!("Error merging commit into perf-tmp: {e:?}"))?;
+
+        // Force the `try-perf` branch to point to what the perf-tmp branch points to
+        client
+            .update_branch("try-perf", &sha)
+            .await
+            .map_err(|e| format!("Error updating the try-perf branch: {e:?}"))?;
+
+        mapping.push((rollup_merge, sha));
+        // Wait to ensure there's enough time for GitHub to checkout these changes before they are overwritten
+        tokio::time::sleep(std::time::Duration::from_secs(15)).await
+    }
+
+    Ok(mapping)
+}
+
 // Returns the PR number
 pub async fn pr_and_try_for_rollup(
     ctxt: Arc<SiteCtxt>,
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index f3aaea01b..e908a483a 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -1,7 +1,7 @@
 use crate::api::{github, ServerResult};
 use crate::github::{
-    branch_for_rollup, client, enqueue_sha, get_authorized_users, parse_homu_comment,
-    pr_and_try_for_rollup,
+    branch_for_rollup, client, enqueue_sha, enqueue_unrolled_try_builds, get_authorized_users,
+    parse_homu_comment, pr_and_try_for_rollup,
 };
 use crate::load::SiteCtxt;
 
@@ -43,8 +43,8 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
     if push.r#ref != "refs/heads/master" {
         return Ok(github::Response);
     }
-    let pr = rollup_pr(&ci_client, &push).await?;
-    let pr = match pr {
+    let rollup_pr = rollup_pr(&main_repo_client, &push).await?;
+    let rollup_pr = match rollup_pr {
         Some(pr) => pr,
         None => return Ok(github::Response),
     };
@@ -57,68 +57,32 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         .skip(1) // skip the head commit
         .take_while(|c| c.message.starts_with("Rollup merge of "));
 
-    let mut prs = Vec::new();
-    for rollup_merge in rollup_merges {
-        let pr_num = ROLLUPED_PR_NUMBER
-            .captures(&rollup_merge.message)
-            .and_then(|c| c.get(0))
-            .map(|m| m.as_str())
-            .ok_or_else(|| {
-                format!(
-                    "Could not get PR number from message: '{}'",
-                    rollup_merge.message
-                )
-            })?;
-        // Fetch the rollup merge commit which should have two parents.
-        // The first parent is in the chain of rollup merge commits all the way back to `previous_master`.
-        // The second parent is the head of the PR that was rolled up. We want the second parent.
-        let commit = ci_client.get_commit(&rollup_merge.sha).await.map_err(|e| {
-            format!(
-                "Error getting rollup merge commit '{}': {e:?}",
-                rollup_merge.sha
-            )
-        })?;
-        assert!(
-            commit.parents.len() == 2,
-            "What we thought was a merge commit was not a merge commit. sha: {}",
-            rollup_merge.sha
-        );
-        let rolled_up_head = &commit.parents[1].sha;
-
-        // Reset perf-tmp to the previous master
-        ci_client
-            .update_branch("perf-tmp", previous_master)
-            .await
-            .map_err(|e| format!("Error updating perf-tmp with previous master: {e:?}"))?;
-
-        // Merge in the rolled up PR's head commit into the previous master
-        let sha = ci_client
-            .merge_branch("perf-tmp", rolled_up_head, "merge")
-            .await
-            .map_err(|e| format!("Error merging commit into perf-tmp: {e:?}"))?;
-
-        // Force the `try-perf` branch to point to what the perf-tmp branch points to
-        ci_client
-            .update_branch("try-perf", &sha)
-            .await
-            .map_err(|e| format!("Error updating the try-perf branch: {e:?}"))?;
+    let mapping = enqueue_unrolled_try_builds(ci_client, rollup_merges, previous_master).await?;
 
-        prs.push((pr_num, sha));
-        // Wait to ensure there's enough time for GitHub to checkout these changes before they are overwritten
-        tokio::time::sleep(std::time::Duration::from_secs(15)).await
-    }
-
-    // Post comment to the rollup PR with the mapping between individual PRs and the new try commits
-    let mapping = prs
+    let mapping = mapping
         .into_iter()
-        .fold(String::new(), |mut string, (pr, commit)| {
+        .map(|(rollup_merge, sha)| {
+            ROLLUPED_PR_NUMBER
+                .captures(&rollup_merge.message)
+                .and_then(|c| c.get(0))
+                .map(|m| (m.as_str(), sha))
+                .ok_or_else(|| {
+                    format!(
+                        "Could not get PR number from message: '{}'",
+                        rollup_merge.message
+                    )
+                })
+        })
+        .fold(ServerResult::Ok(String::new()), |string, n| {
             use std::fmt::Write;
+            let (pr, commit) = n?;
+            let mut string = string?;
             write!(&mut string, "#{pr}: {commit}\n").unwrap();
-            string
-        });
+            Ok(string)
+        })?;
     let msg =
         format!("Try perf builds for each individual rolled up PR have been enqueued:\n{mapping}");
-    main_repo_client.post_comment(pr, msg).await;
+    main_repo_client.post_comment(rollup_pr, msg).await;
     Ok(github::Response)
 }
 

From 0f292614ba091a3a77f13b9c28b0de9abb7ef5b6 Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 11:48:34 +0200
Subject: [PATCH 08/12] Share request building

---
 site/src/github/client.rs | 138 +++++++++++++++-----------------------
 1 file changed, 53 insertions(+), 85 deletions(-)

diff --git a/site/src/github/client.rs b/site/src/github/client.rs
index 217c99c24..44a900e1f 100644
--- a/site/src/github/client.rs
+++ b/site/src/github/client.rs
@@ -41,15 +41,8 @@ impl Client {
             sha: &'a str,
         }
         let url = format!("{}/git/refs", self.repository_url);
-        let response = self
-            .inner
-            .post(&url)
-            .json(&CreateRefRequest { ref_, sha })
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token))
-            .send()
-            .await
-            .context("POST git/refs failed")?;
+        let req = self.inner.post(&url).json(&CreateRefRequest { ref_, sha });
+        let response = self.send(req).await.context("POST git/refs failed")?;
         if response.status() != reqwest::StatusCode::CREATED {
             anyhow::bail!("{:?} != 201 CREATED", response.status());
         }
@@ -78,21 +71,14 @@ impl Client {
         }
 
         let url = format!("{}/pulls", self.repository_url);
-        let response = self
-            .inner
-            .post(&url)
-            .json(&CreatePrRequest {
-                title,
-                head,
-                base,
-                description,
-                draft,
-            })
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token))
-            .send()
-            .await
-            .context("POST pulls failed")?;
+        let req = self.inner.post(&url).json(&CreatePrRequest {
+            title,
+            head,
+            base,
+            description,
+            draft,
+        });
+        let response = self.send(req).await.context("POST pulls failed")?;
         if response.status() != reqwest::StatusCode::CREATED {
             anyhow::bail!("{:?} != 201 CREATED", response.status());
         }
@@ -107,17 +93,14 @@ impl Client {
             force: bool,
         }
         let url = format!("{}/git/refs/{}", self.repository_url, branch);
-        let commit_response = self
+        let req = self
             .inner
             .patch(&url)
-            .json(&UpdateBranchRequest { sha, force: true })
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token))
-            .send()
-            .await
-            .context("PATCH git/refs failed")?;
-        if commit_response.status() != reqwest::StatusCode::OK {
-            anyhow::bail!("{:?} != 200 OK", commit_response.status());
+            .json(&UpdateBranchRequest { sha, force: true });
+
+        let response = self.send(req).await.context("PATCH git/refs failed")?;
+        if response.status() != reqwest::StatusCode::OK {
+            anyhow::bail!("{:?} != 200 OK", response.status());
         }
 
         Ok(())
@@ -136,19 +119,12 @@ impl Client {
             commit_message: &'a str,
         }
         let url = format!("{}/merges", self.repository_url);
-        let response = self
-            .inner
-            .patch(&url)
-            .json(&MergeBranchRequest {
-                base: branch,
-                head: sha,
-                commit_message,
-            })
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token))
-            .send()
-            .await
-            .context("PATCH /merges failed")?;
+        let req = self.inner.patch(&url).json(&MergeBranchRequest {
+            base: branch,
+            head: sha,
+            commit_message,
+        });
+        let response = self.send(req).await.context("PATCH /merges failed")?;
         if !response.status().is_success() {
             anyhow::bail!("{:?} != 201 CREATED", response.status());
         }
@@ -169,24 +145,18 @@ impl Client {
             parents: &'a [&'a str],
         }
         let url = format!("{}/git/commits", self.repository_url);
-        let commit_response = self
-            .inner
-            .post(&url)
-            .json(&CreateCommitRequest {
-                message,
-                tree,
-                parents,
-            })
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token))
-            .send()
-            .await
-            .context("POST git/commits failed")?;
-        if commit_response.status() != reqwest::StatusCode::CREATED {
-            anyhow::bail!("{:?} != 201 CREATED", commit_response.status());
+        let req = self.inner.post(&url).json(&CreateCommitRequest {
+            message,
+            tree,
+            parents,
+        });
+
+        let response = self.send(req).await.context("POST git/commits failed")?;
+        if response.status() != reqwest::StatusCode::CREATED {
+            anyhow::bail!("{:?} != 201 CREATED", response.status());
         }
 
-        Ok(commit_response
+        Ok(response
             .json::<CreateCommitResponse>()
             .await
             .context("deserializing failed")?
@@ -195,14 +165,8 @@ impl Client {
 
     pub async fn get_issue(&self, number: u64) -> anyhow::Result<Issue> {
         let url = format!("{}/issues/{}", self.repository_url, number);
-        let response = self
-            .inner
-            .get(&url)
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token))
-            .send()
-            .await
-            .context("cannot get issue")?;
+        let req = self.inner.get(&url);
+        let response = self.send(req).await.context("cannot get issue")?;
         if !response.status().is_success() {
             anyhow::bail!("{:?} != 200 OK", response.status());
         }
@@ -212,15 +176,9 @@ impl Client {
 
     pub async fn get_commit(&self, sha: &str) -> anyhow::Result<Commit> {
         let url = format!("{}/commits/{}", self.repository_url, sha);
-        let commit_response = self
-            .inner
-            .get(&url)
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token))
-            .send()
-            .await
-            .context("cannot get commit")?;
-        commit_response
+        let req = self.inner.get(&url);
+        let response = self.send(req).await.context("cannot get commit")?;
+        response
             .json()
             .await
             .map_err(|e| anyhow::anyhow!("cannot deserialize commit: {:?}", e))
@@ -235,19 +193,29 @@ impl Client {
             pub body: String,
         }
         let body = body.into();
-        let client = reqwest::Client::new();
-        let req = client
+        let req = self
+            .inner
             .post(&format!("{}/issues/{}/comments", self.repository_url, pr))
             .json(&PostComment {
                 body: body.to_owned(),
-            })
-            .header(USER_AGENT, "perf-rust-lang-org-server")
-            .basic_auth("rust-timer", Some(&self.token));
+            });
+        let resp = self.send(req).await;
 
-        if let Err(e) = req.send().await {
+        if let Err(e) = resp {
             eprintln!("failed to post comment: {:?}", e);
         }
     }
+
+    async fn send(
+        &self,
+        request: reqwest::RequestBuilder,
+    ) -> Result<reqwest::Response, reqwest::Error> {
+        request
+            .header(USER_AGENT, "perf-rust-lang-org-server")
+            .basic_auth("rust-timer", Some(&self.token))
+            .send()
+            .await
+    }
 }
 
 #[derive(Debug, serde::Deserialize)]

From 5f9f31731fbe2fe4db998c89bba8ae70d1a378fd Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 12:18:04 +0200
Subject: [PATCH 09/12] Fix issues

---
 site/src/github/client.rs           |  7 +++++--
 site/src/request_handlers/github.rs | 12 ++++++++----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/site/src/github/client.rs b/site/src/github/client.rs
index 44a900e1f..dd9fd68b8 100644
--- a/site/src/github/client.rs
+++ b/site/src/github/client.rs
@@ -92,7 +92,7 @@ impl Client {
             sha: &'a str,
             force: bool,
         }
-        let url = format!("{}/git/refs/{}", self.repository_url, branch);
+        let url = format!("{}/git/refs/heads/{}", self.repository_url, branch);
         let req = self
             .inner
             .patch(&url)
@@ -119,7 +119,7 @@ impl Client {
             commit_message: &'a str,
         }
         let url = format!("{}/merges", self.repository_url);
-        let req = self.inner.patch(&url).json(&MergeBranchRequest {
+        let req = self.inner.post(&url).json(&MergeBranchRequest {
             base: branch,
             head: sha,
             commit_message,
@@ -178,6 +178,9 @@ impl Client {
         let url = format!("{}/commits/{}", self.repository_url, sha);
         let req = self.inner.get(&url);
         let response = self.send(req).await.context("cannot get commit")?;
+        if !response.status().is_success() {
+            anyhow::bail!("{:?} != 200 OK", response.status());
+        }
         response
             .json()
             .await
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index e908a483a..c42a8a65e 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -36,10 +36,14 @@ pub async fn handle_github(
 }
 
 async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<github::Response> {
-    let ci_client =
-        client::Client::from_ctxt(&ctxt, "https://github.com/rust-lang-ci/rust".to_owned());
-    let main_repo_client =
-        client::Client::from_ctxt(&ctxt, "https://github.com/rust-lang/rust".to_owned());
+    let ci_client = client::Client::from_ctxt(
+        &ctxt,
+        "https://api.github.com/repos/rust-lang-ci/rust".to_owned(),
+    );
+    let main_repo_client = client::Client::from_ctxt(
+        &ctxt,
+        "https://api.github.com/repos/rust-lang/rust".to_owned(),
+    );
     if push.r#ref != "refs/heads/master" {
         return Ok(github::Response);
     }

From 37c646df6e1ac19f30a37a84eed46cd14470e22c Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 12:26:08 +0200
Subject: [PATCH 10/12] Wrong URL

---
 site/src/request_handlers/github.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index c42a8a65e..c139fc425 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -145,8 +145,10 @@ async fn handle_rust_timer(
     comment: github::Comment,
     issue: github::Issue,
 ) -> ServerResult<github::Response> {
-    let main_repo_client =
-        client::Client::from_ctxt(&ctxt, "https://github.com/rust-lang/rust".to_owned());
+    let main_repo_client = client::Client::from_ctxt(
+        &ctxt,
+        "https://api.github.com/repos/rust-lang/rust".to_owned(),
+    );
     if comment.author_association != github::Association::Owner
         && !get_authorized_users().await?.contains(&comment.user.id)
     {

From 69a2371cd1b1894e03e809c51987c16858e0061a Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 12:49:10 +0200
Subject: [PATCH 11/12] Fix issue with PR number extraction

---
 site/src/github.rs                  | 38 ++++++++++++++++++++++++++++
 site/src/request_handlers/github.rs | 39 +++--------------------------
 2 files changed, 42 insertions(+), 35 deletions(-)

diff --git a/site/src/github.rs b/site/src/github.rs
index 92ebebc8c..6df299f69 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -84,6 +84,44 @@ pub async fn enqueue_unrolled_try_builds<'a>(
     Ok(mapping)
 }
 
+lazy_static::lazy_static! {
+    static ref ROLLUP_PR_NUMBER: regex::Regex =
+        regex::Regex::new(r#"^Auto merge of #(\d+)"#).unwrap();
+}
+
+// Gets the pr number for the associated rollup PR message. Returns None if this is not a rollup PR
+pub async fn rollup_pr(client: &client::Client, message: &str) -> Result<Option<u32>, String> {
+    if !message.starts_with("Auto merge of") {
+        return Ok(None);
+    }
+
+    let number = ROLLUP_PR_NUMBER
+        .captures(&message)
+        .and_then(|c| c.get(1))
+        .map(|m| {
+            println!("{}", m.as_str());
+            m.as_str().parse::<u64>()
+        })
+        .transpose()
+        .map_err(|e| format!("Error parsing PR number from '{message}': {e:?}"))?;
+
+    let number = match number {
+        Some(n) => n,
+        None => return Ok(None),
+    };
+
+    let issue = client
+        .get_issue(number)
+        .await
+        .map_err(|e| format!("Error fetching PR #{number} {e:?}"))?;
+
+    Ok(issue
+        .labels
+        .iter()
+        .any(|l| l.name == "rollup")
+        .then(|| issue.number))
+}
+
 // Returns the PR number
 pub async fn pr_and_try_for_rollup(
     ctxt: Arc<SiteCtxt>,
diff --git a/site/src/request_handlers/github.rs b/site/src/request_handlers/github.rs
index c139fc425..3ae8cf1c7 100644
--- a/site/src/request_handlers/github.rs
+++ b/site/src/request_handlers/github.rs
@@ -1,7 +1,7 @@
 use crate::api::{github, ServerResult};
 use crate::github::{
     branch_for_rollup, client, enqueue_sha, enqueue_unrolled_try_builds, get_authorized_users,
-    parse_homu_comment, pr_and_try_for_rollup,
+    parse_homu_comment, pr_and_try_for_rollup, rollup_pr,
 };
 use crate::load::SiteCtxt;
 
@@ -44,10 +44,10 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         &ctxt,
         "https://api.github.com/repos/rust-lang/rust".to_owned(),
     );
-    if push.r#ref != "refs/heads/master" {
+    if push.r#ref != "refs/heads/master" || push.sender.login != "bors" {
         return Ok(github::Response);
     }
-    let rollup_pr = rollup_pr(&main_repo_client, &push).await?;
+    let rollup_pr = rollup_pr(&main_repo_client, &push.head_commit.message).await?;
     let rollup_pr = match rollup_pr {
         Some(pr) => pr,
         None => return Ok(github::Response),
@@ -68,7 +68,7 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
         .map(|(rollup_merge, sha)| {
             ROLLUPED_PR_NUMBER
                 .captures(&rollup_merge.message)
-                .and_then(|c| c.get(0))
+                .and_then(|c| c.get(1))
                 .map(|m| (m.as_str(), sha))
                 .ok_or_else(|| {
                     format!(
@@ -90,37 +90,6 @@ async fn handle_push(ctxt: Arc<SiteCtxt>, push: github::Push) -> ServerResult<gi
     Ok(github::Response)
 }
 
-// Gets the pr number for the associated rollup PR. Returns None if this is not a rollup PR
-async fn rollup_pr(client: &client::Client, push: &github::Push) -> ServerResult<Option<u32>> {
-    macro_rules! get {
-        ($x:expr) => {
-            match $x {
-                Some(x) => x,
-                None => return Ok(None),
-            }
-        };
-    }
-    let is_bors =
-        push.sender.login == "bors" && push.head_commit.message.starts_with("Auto merge of");
-
-    if !is_bors {
-        return Ok(None);
-    }
-    let captures = get!(ROLLUP_PR_NUMBER.captures(&push.head_commit.message));
-    let number = get!(get!(captures.get(0)).as_str().parse::<u64>().ok());
-
-    let issue = client
-        .get_issue(number)
-        .await
-        .map_err(|e| format!("Error fetching PR #{number} {e:?}"))?;
-
-    Ok(issue
-        .labels
-        .iter()
-        .any(|l| l.name == "rollup")
-        .then(|| issue.number))
-}
-
 async fn handle_issue(
     ctxt: Arc<SiteCtxt>,
     issue: github::Issue,

From c9813b3eef3c0ff95012571be98b49408ef3e626 Mon Sep 17 00:00:00 2001
From: Ryan Levick <me@ryanlevick.com>
Date: Mon, 1 Aug 2022 13:53:14 +0200
Subject: [PATCH 12/12] remove rogue println

---
 site/src/github.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/site/src/github.rs b/site/src/github.rs
index 6df299f69..9e29ee671 100644
--- a/site/src/github.rs
+++ b/site/src/github.rs
@@ -98,10 +98,7 @@ pub async fn rollup_pr(client: &client::Client, message: &str) -> Result<Option<
     let number = ROLLUP_PR_NUMBER
         .captures(&message)
         .and_then(|c| c.get(1))
-        .map(|m| {
-            println!("{}", m.as_str());
-            m.as_str().parse::<u64>()
-        })
+        .map(|m| m.as_str().parse::<u64>())
         .transpose()
         .map_err(|e| format!("Error parsing PR number from '{message}': {e:?}"))?;