Remove the RepositoryLoader trait

Author: Kobzol

src/bin/bors.rs

@@ -88,7 +88,9 @@ fn try_main(opts: Opts) -> anyhow::Result<()> {
             "https://api.github.com".to_string(),
             opts.private_key.into_bytes().into(),
         )?;
-        let repos = client.load_repositories(&team_api).await?;
+        let repos = RepositoryLoader::new(client.clone())
+            .load_repositories(&team_api)
+            .await?;
         Ok::<_, anyhow::Error>((client, repos))
     })?;
 

src/bors/handlers/mod.rs

@@ -121,7 +121,7 @@ pub static WAIT_FOR_REFRESH: TestSyncMarker = TestSyncMarker::new();
 pub async fn handle_bors_global_event(
     event: BorsGlobalEvent,
     ctx: Arc<BorsContext>,
-    repo_loader: &dyn RepositoryLoader,
+    repo_loader: &RepositoryLoader,
     team_api_client: &TeamApiClient,
 ) -> anyhow::Result<()> {
     let db = Arc::clone(&ctx.db);
@@ -243,7 +243,7 @@ async fn handle_comment(
 
 async fn reload_repos(
     ctx: Arc<BorsContext>,
-    repo_loader: &dyn RepositoryLoader,
+    repo_loader: &RepositoryLoader,
     team_api_client: &TeamApiClient,
 ) -> anyhow::Result<()> {
     let reloaded_repos = repo_loader.load_repositories(team_api_client).await?;

src/bors/mod.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use arc_swap::ArcSwap;
-use axum::async_trait;
+use octocrab::Octocrab;
 
 pub use command::CommandParser;
 pub use comment::Comment;
@@ -12,6 +12,7 @@ pub use handlers::{handle_bors_global_event, handle_bors_repository_event};
 
 use crate::config::RepositoryConfig;
 use crate::github::api::client::GithubRepositoryClient;
+use crate::github::api::load_repositories;
 use crate::github::GithubRepoName;
 use crate::permissions::UserPermissions;
 use crate::TeamApiClient;
@@ -22,15 +23,23 @@ mod context;
 pub mod event;
 mod handlers;
 
-/// Temporary trait to sastify the test mocking.
-/// TODO: Remove this trait once we move to mock REST API call.
-#[async_trait]
-pub trait RepositoryLoader: Send + Sync {
+/// Loads repositories through a global GitHub client.
+pub struct RepositoryLoader {
+    client: Octocrab,
+}
+
+impl RepositoryLoader {
+    pub fn new(client: Octocrab) -> Self {
+        Self { client }
+    }
+
     /// Load state of repositories.
-    async fn load_repositories(
+    pub async fn load_repositories(
         &self,
         team_api_client: &TeamApiClient,
-    ) -> anyhow::Result<HashMap<GithubRepoName, anyhow::Result<RepositoryState>>>;
+    ) -> anyhow::Result<HashMap<GithubRepoName, anyhow::Result<RepositoryState>>> {
+        load_repositories(&self.client, team_api_client).await
+    }
 }
 
 #[derive(Clone, Debug)]

src/github/api/client.rs

@@ -1,21 +1,15 @@
-use std::collections::HashMap;
-
 use anyhow::Context;
-use axum::async_trait;
 use octocrab::models::{App, Repository};
 use octocrab::{Error, Octocrab};
 use tracing::log;
 
 use crate::bors::event::PullRequestComment;
-use crate::bors::{CheckSuite, CheckSuiteStatus, Comment, RepositoryLoader, RepositoryState};
+use crate::bors::{CheckSuite, CheckSuiteStatus, Comment};
 use crate::config::{RepositoryConfig, CONFIG_FILE_PATH};
 use crate::database::RunId;
 use crate::github::api::base_github_html_url;
 use crate::github::api::operations::{merge_branches, set_branch_to_commit, MergeError};
 use crate::github::{Branch, CommitSha, GithubRepoName, PullRequest, PullRequestNumber};
-use crate::permissions::TeamApiClient;
-
-use super::load_repositories;
 
 /// Provides access to a single app installation (repository) using the GitHub API.
 pub struct GithubRepositoryClient {
@@ -288,16 +282,6 @@ impl GithubRepositoryClient {
     }
 }
 
-#[async_trait]
-impl RepositoryLoader for Octocrab {
-    async fn load_repositories(
-        &self,
-        team_api_client: &TeamApiClient,
-    ) -> anyhow::Result<HashMap<GithubRepoName, anyhow::Result<RepositoryState>>> {
-        load_repositories(self, team_api_client).await
-    }
-}
-
 fn github_pr_to_pr(pr: octocrab::models::pulls::PullRequest) -> PullRequest {
     PullRequest {
         number: pr.number.into(),
@@ -343,7 +327,10 @@ mod tests {
         .await;
         let client = mock.github_client();
         let team_api_client = mock.team_api_client();
-        let mut repos = client.load_repositories(&team_api_client).await.unwrap();
+        let mut repos = RepositoryLoader::new(client)
+            .load_repositories(&team_api_client)
+            .await
+            .unwrap();
         assert_eq!(repos.len(), 2);
 
         let repo = repos

src/github/server.rs

@@ -2,7 +2,7 @@ use crate::bors::event::BorsEvent;
 use crate::bors::{handle_bors_global_event, handle_bors_repository_event, BorsContext};
 use crate::github::webhook::GitHubWebhook;
 use crate::github::webhook::WebhookSecret;
-use crate::{BorsGlobalEvent, BorsRepositoryEvent, TeamApiClient};
+use crate::{BorsGlobalEvent, BorsRepositoryEvent, RepositoryLoader, TeamApiClient};
 
 use anyhow::Error;
 use axum::extract::State;
@@ -87,6 +87,7 @@ pub fn create_bors_process(
 ) {
     let (repository_tx, repository_rx) = mpsc::channel::<BorsRepositoryEvent>(1024);
     let (global_tx, global_rx) = mpsc::channel::<BorsGlobalEvent>(1024);
+    let repo_loader = RepositoryLoader::new(gh_client);
 
     let service = async move {
         let ctx = Arc::new(ctx);
@@ -99,7 +100,7 @@ pub fn create_bors_process(
         {
             tokio::join!(
                 consume_repository_events(ctx.clone(), repository_rx),
-                consume_global_events(ctx.clone(), global_rx, gh_client, team_api)
+                consume_global_events(ctx.clone(), global_rx, repo_loader, team_api)
             );
         }
         // In real execution, the bot runs forever. If there is something that finishes
@@ -111,7 +112,7 @@ pub fn create_bors_process(
                 _ = consume_repository_events(ctx.clone(), repository_rx) => {
                     tracing::error!("Repository event handling process has ended");
                 }
-                _ = consume_global_events(ctx.clone(), global_rx, gh_client, team_api) => {
+                _ = consume_global_events(ctx.clone(), global_rx, repo_loader, team_api) => {
                     tracing::error!("Global event handling process has ended");
                 }
             }
@@ -141,15 +142,15 @@ async fn consume_repository_events(
 async fn consume_global_events(
     ctx: Arc<BorsContext>,
     mut global_rx: mpsc::Receiver<BorsGlobalEvent>,
-    gh_client: Octocrab,
+    loader: RepositoryLoader,
     team_api: TeamApiClient,
 ) {
     while let Some(event) = global_rx.recv().await {
         let ctx = ctx.clone();
 
         let span = tracing::info_span!("GlobalEvent");
         tracing::debug!("Received global event: {event:#?}");
-        if let Err(error) = handle_bors_global_event(event, ctx, &gh_client, &team_api)
+        if let Err(error) = handle_bors_global_event(event, ctx, &loader, &team_api)
             .instrument(span.clone())
             .await
         {