Install apps for new repositories

Author: Kobzol

src/github/api/write.rs

@@ -231,6 +231,7 @@ impl GitHubWrite {
         if self.dry_run {
             Ok(Repo {
                 id: String::from("ID"),
+                repo_id: 0,
                 name: name.to_string(),
                 org: org.to_string(),
                 description: settings.description.clone(),
@@ -273,6 +274,23 @@ impl GitHubWrite {
         Ok(())
     }
 
+    pub(crate) fn add_repo_to_app_installation(
+        &self,
+        installation_id: u64,
+        repository_id: u64,
+    ) -> anyhow::Result<()> {
+        debug!("Adding installation {installation_id} to repository {repository_id}");
+        if !self.dry_run {
+            self.client
+                .req(
+                    Method::PUT,
+                    &format!("user/installations/{installation_id}/repositories/{repository_id}"),
+                )?
+                .send()?;
+        }
+        Ok(())
+    }
+
     /// Update a team's permissions to a repo
     pub(crate) fn update_team_repo_permissions(
         &self,

src/github/mod.rs

@@ -3,11 +3,13 @@ mod api;
 mod tests;
 
 use self::api::{BranchProtectionOp, TeamPrivacy, TeamRole};
-use crate::github::api::{GithubRead, Login, PushAllowanceActor, RepoPermission, RepoSettings};
+use crate::github::api::{
+    GithubRead, Login, PushAllowanceActor, Repo, RepoPermission, RepoSettings,
+};
 use log::debug;
 use rust_team_data::v1::Bot;
 use std::collections::{HashMap, HashSet};
-use std::fmt::Write;
+use std::fmt::{Display, Formatter, Write};
 
 pub(crate) use self::api::{GitHubApiRead, GitHubWrite, HttpClient};
 
@@ -26,7 +28,7 @@ pub(crate) fn create_diff(
 type OrgName = String;
 type RepoName = String;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 enum GithubApp {
     RenovateBot,
 }
@@ -40,20 +42,34 @@ impl GithubApp {
     }
 }
 
+impl Display for GithubApp {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GithubApp::RenovateBot => f.write_str("RenovateBot"),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
-struct GithubAppInstallation {
+struct OrgAppInstallation {
     app: GithubApp,
     installation_id: u64,
     repositories: HashSet<RepoName>,
 }
 
+#[derive(Clone, Debug, PartialEq)]
+struct AppInstallation {
+    app: GithubApp,
+    installation_id: u64,
+}
+
 struct SyncGitHub {
     github: Box<dyn GithubRead>,
     teams: Vec<rust_team_data::v1::Team>,
     repos: Vec<rust_team_data::v1::Repo>,
     usernames_cache: HashMap<u64, String>,
     org_owners: HashMap<OrgName, HashSet<u64>>,
-    org_apps: HashMap<OrgName, Vec<GithubAppInstallation>>,
+    org_apps: HashMap<OrgName, Vec<OrgAppInstallation>>,
 }
 
 impl SyncGitHub {
@@ -88,7 +104,7 @@ impl SyncGitHub {
         for org in &orgs {
             org_owners.insert((*org).to_string(), github.org_owners(org)?);
 
-            let mut installations: Vec<GithubAppInstallation> = vec![];
+            let mut installations: Vec<OrgAppInstallation> = vec![];
 
             for installation in github.org_app_installations(org)? {
                 if let Some(app) = GithubApp::from_id(installation.app_id) {
@@ -98,7 +114,7 @@ impl SyncGitHub {
                     {
                         repositories.insert(repo_installation.name);
                     }
-                    installations.push(GithubAppInstallation {
+                    installations.push(OrgAppInstallation {
                         app,
                         installation_id: installation.installation_id,
                         repositories,
@@ -299,6 +315,7 @@ impl SyncGitHub {
                     },
                     permissions,
                     branch_protections,
+                    app_installations: self.diff_app_installations(expected_repo, &[])?,
                 }));
             }
         };
@@ -392,6 +409,52 @@ impl SyncGitHub {
         Ok(branch_protection_diffs)
     }
 
+    fn diff_app_installations(
+        &self,
+        expected_repo: &rust_team_data::v1::Repo,
+        existing_installations: &[AppInstallation],
+    ) -> anyhow::Result<Vec<AppInstallationDiff>> {
+        let mut diff = vec![];
+        let mut found_apps = Vec::new();
+
+        // Find apps that should be enabled on the repository
+        for app in expected_repo.bots.iter().filter_map(|bot| match bot {
+            Bot::Renovate => Some(GithubApp::RenovateBot),
+            _ => None,
+        }) {
+            // Find installation ID of this app on GitHub
+            let gh_installation = self
+                .org_apps
+                .get(&expected_repo.org)
+                .and_then(|installations| {
+                    installations
+                        .iter()
+                        .find(|installation| installation.app == app)
+                        .map(|i| i.installation_id)
+                });
+            let Some(gh_installation) = gh_installation else {
+                log::warn!("Application {app} should be enabled for repository {}/{}, but it is not installed on GitHub", expected_repo.org, expected_repo.name);
+                continue;
+            };
+            let installation = AppInstallation {
+                app,
+                installation_id: gh_installation,
+            };
+            found_apps.push(installation.clone());
+
+            if !existing_installations.contains(&installation) {
+                diff.push(AppInstallationDiff::Add(installation));
+            }
+        }
+        for existing in existing_installations {
+            if !found_apps.contains(existing) {
+                diff.push(AppInstallationDiff::Remove(existing.clone()));
+            }
+        }
+
+        Ok(diff)
+    }
+
     fn expected_role(&self, org: &str, user: u64) -> TeamRole {
         if let Some(true) = self
             .org_owners
@@ -499,6 +562,7 @@ fn bot_name(bot: &Bot) -> Option<&str> {
         Bot::RustTimer => Some("rust-timer"),
         Bot::Rustbot => Some("rustbot"),
         Bot::Rfcbot => Some("rfcbot"),
+        Bot::Renovate => None,
     }
 }
 
@@ -619,6 +683,7 @@ struct CreateRepoDiff {
     settings: RepoSettings,
     permissions: Vec<RepoPermissionAssignmentDiff>,
     branch_protections: Vec<(String, api::BranchProtection)>,
+    app_installations: Vec<AppInstallationDiff>,
 }
 
 impl CreateRepoDiff {
@@ -636,6 +701,11 @@ impl CreateRepoDiff {
             }
             .apply(sync, &self.org, &self.name, &repo.id)?;
         }
+
+        for installation in &self.app_installations {
+            installation.apply(sync, &repo)?;
+        }
+
         Ok(())
     }
 }
@@ -664,6 +734,10 @@ impl std::fmt::Display for CreateRepoDiff {
             writeln!(&mut f, "    {branch_name}")?;
             log_branch_protection(branch_protection, None, &mut f)?;
         }
+        writeln!(f, "  App Installations:")?;
+        for diff in &self.app_installations {
+            write!(f, "{diff}")?;
+        }
         Ok(())
     }
 }
@@ -930,6 +1004,38 @@ enum BranchProtectionDiffOperation {
     Delete(String),
 }
 
+enum AppInstallationDiff {
+    Add(AppInstallation),
+    Remove(AppInstallation),
+}
+
+impl AppInstallationDiff {
+    fn apply(&self, sync: &GitHubWrite, repo: &Repo) -> anyhow::Result<()> {
+        match self {
+            AppInstallationDiff::Add(app) => {
+                sync.add_repo_to_app_installation(app.installation_id, repo.repo_id)?;
+            }
+            AppInstallationDiff::Remove(_) => {
+                todo!()
+            }
+        }
+        Ok(())
+    }
+}
+
+impl std::fmt::Display for AppInstallationDiff {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AppInstallationDiff::Add(app) => {
+                writeln!(f, "    Install app {}", app.app)
+            }
+            AppInstallationDiff::Remove(app) => {
+                writeln!(f, "    Remove app {}", app.app)
+            }
+        }
+    }
+}
+
 #[derive(Debug)]
 enum TeamDiff {
     Create(CreateTeamDiff),