Remove sync-team CLI and call it from team as a library

Author: Kobzol

Cargo.lock

@@ -22,6 +22,8 @@ serde_json = "1"
 serde-untagged = "0.1"
 toml = "0.8"
 
+sync-team = { path = "sync-team" }
+
 [dev-dependencies]
 ansi_term = "0.12.1"
 atty = "0.2.14"

Cargo.toml

@@ -9,6 +9,8 @@ mod schema;
 mod static_api;
 mod validate;
 
+const AVAILABLE_SERVICES: &[&str] = &["github", "mailgun", "zulip"];
+
 const USER_AGENT: &str = "https://github.com/rust-lang/team (infra@rust-lang.org)";
 
 use api::zulip::ZulipApi;
@@ -23,6 +25,8 @@ use clap::Parser;
 use log::{error, info, warn};
 use std::collections::{BTreeMap, HashMap};
 use std::path::PathBuf;
+use sync_team::run_sync_team;
+use sync_team::team_api::TeamApi;
 
 #[derive(clap::ValueEnum, Clone, Debug)]
 enum DumpIndividualAccessGroupBy {
@@ -83,6 +87,15 @@ enum Cli {
     /// CI scripts
     #[clap(subcommand)]
     Ci(CiOpts),
+    /// Perform synchronization of the local data to live services.
+    /// Environment variables:
+    /// - GITHUB_TOKEN          Authentication token with GitHub
+    /// - MAILGUN_API_TOKEN     Authentication token with Mailgun
+    /// - EMAIL_ENCRYPTION_KEY  Key used to decrypt encrypted emails in the team repo
+    /// - ZULIP_USERNAME        Username of the Zulip bot
+    /// - ZULIP_API_TOKEN       Authentication token of the Zulip bot
+    #[clap(verbatim_doc_comment)]
+    Sync(SyncOpts),
 }
 
 #[derive(clap::Parser, Debug)]
@@ -93,11 +106,42 @@ enum CiOpts {
     CheckCodeowners,
 }
 
+#[derive(clap::Parser, Debug)]
+struct SyncOpts {
+    /// Comma-separated list of available services
+    #[clap(long, global(true), value_parser = clap::builder::PossibleValuesParser::new(
+        AVAILABLE_SERVICES
+    ), value_delimiter = ',')]
+    services: Vec<String>,
+
+    /// Path to a checkout of `rust-lang/team`.
+    #[clap(long, global(true), conflicts_with = "team_json")]
+    team_repo: Option<PathBuf>,
+
+    /// Path to a directory with prebuilt JSON data from the `team` repository.
+    #[clap(long, global(true))]
+    team_json: Option<PathBuf>,
+
+    #[clap(subcommand)]
+    command: Option<SyncCommand>,
+}
+
+#[derive(clap::Parser, Debug)]
+enum SyncCommand {
+    /// Try to apply changes, but do not send any outgoing API requests.
+    DryRun,
+    /// Only print a diff of what would be changed.
+    PrintPlan,
+    /// Apply the changes to the specified services.
+    Apply,
+}
+
 fn main() {
     let mut env = env_logger::Builder::new();
     env.format_timestamp(None);
     env.format_module_path(false);
     env.filter_module("rust_team", log::LevelFilter::Info);
+    env.filter_module("sync_team", log::LevelFilter::Info);
     if std::env::var("RUST_TEAM_FORCE_COLORS").is_ok() {
         env.write_style(env_logger::WriteStyle::Always);
     }
@@ -406,6 +450,16 @@ fn run() -> Result<(), Error> {
             CiOpts::GenerateCodeowners => generate_codeowners_file(data)?,
             CiOpts::CheckCodeowners => check_codeowners(data)?,
         },
+        Cli::Sync(opts) => {
+            if let Err(err) = perform_sync(opts) {
+                // Display shows just the first element of the chain.
+                error!("failed: {}", err);
+                for cause in err.chain().skip(1) {
+                    error!("caused by: {}", cause);
+                }
+                std::process::exit(1);
+            }
+        }
     }
 
     Ok(())
@@ -437,3 +491,27 @@ fn dump_team_members(
     }
     Ok(())
 }
+
+fn perform_sync(opts: SyncOpts) -> anyhow::Result<()> {
+    let team_api = if let Some(path) = opts.team_repo {
+        TeamApi::Checkout(path)
+    } else if let Some(path) = opts.team_json {
+        TeamApi::Prebuilt(path)
+    } else {
+        TeamApi::Production
+    };
+
+    let mut services = opts.services;
+    if services.is_empty() {
+        info!("no service to synchronize specified, defaulting to all services");
+        services = AVAILABLE_SERVICES
+            .iter()
+            .map(|s| (*s).to_string())
+            .collect();
+    }
+
+    let subcmd = opts.command.unwrap_or(SyncCommand::DryRun);
+    let only_print_plan = matches!(subcmd, SyncCommand::PrintPlan);
+    let dry_run = only_print_plan || matches!(subcmd, SyncCommand::DryRun);
+    run_sync_team(team_api, &services, dry_run, only_print_plan)
+}

src/main.rs

@@ -5,10 +5,8 @@ authors = ["Pietro Albini <pietro@pietroalbini.org>"]
 edition = "2024"
 
 [dependencies]
-clap = { version = "4.5", features = ["derive", "env"] }
 reqwest = { version = "0.12.8", features = ["blocking", "json", "rustls-tls", "charset", "http2", "macos-system-configuration"], default-features = false }
 log = "0.4"
-env_logger = "0.11"
 rust_team_data = { path = "../rust_team_data", features = ["email-encryption"] }
 serde = { version = "1.0", features = ["derive"] }
 anyhow = "1.0"

sync-team/Cargo.toml

@@ -0,0 +1,69 @@
+mod github;
+mod mailgun;
+pub mod team_api;
+mod utils;
+mod zulip;
+
+use crate::github::{GitHubApiRead, GitHubWrite, HttpClient, create_diff};
+use crate::team_api::TeamApi;
+use crate::zulip::SyncZulip;
+use anyhow::Context;
+use log::{info, warn};
+use secrecy::SecretString;
+
+const USER_AGENT: &str = "rust-lang teams sync (https://github.com/rust-lang/sync-team)";
+
+pub fn run_sync_team(
+    team_api: TeamApi,
+    services: &[String],
+    dry_run: bool,
+    only_print_plan: bool,
+) -> anyhow::Result<()> {
+    if dry_run {
+        warn!("sync-team is running in dry mode, no changes will be applied.");
+    }
+
+    for service in services {
+        info!("synchronizing {}", service);
+        match service.as_str() {
+            "github" => {
+                let client = HttpClient::new()?;
+                let gh_read = Box::new(GitHubApiRead::from_client(client.clone())?);
+                let teams = team_api.get_teams()?;
+                let repos = team_api.get_repos()?;
+                let diff = create_diff(gh_read, teams, repos)?;
+                if !diff.is_empty() {
+                    info!("{}", diff);
+                }
+                if !only_print_plan {
+                    let gh_write = GitHubWrite::new(client, dry_run)?;
+                    diff.apply(&gh_write)?;
+                }
+            }
+            "mailgun" => {
+                let token = SecretString::from(get_env("MAILGUN_API_TOKEN")?);
+                let encryption_key = get_env("EMAIL_ENCRYPTION_KEY")?;
+                mailgun::run(token, &encryption_key, &team_api, dry_run)?;
+            }
+            "zulip" => {
+                let username = get_env("ZULIP_USERNAME")?;
+                let token = SecretString::from(get_env("ZULIP_API_TOKEN")?);
+                let sync = SyncZulip::new(username, token, &team_api, dry_run)?;
+                let diff = sync.diff_all()?;
+                if !diff.is_empty() {
+                    info!("{}", diff);
+                }
+                if !only_print_plan {
+                    diff.apply(&sync)?;
+                }
+            }
+            _ => panic!("unknown service: {service}"),
+        }
+    }
+
+    Ok(())
+}
+
+fn get_env(key: &str) -> anyhow::Result<String> {
+    std::env::var(key).with_context(|| format!("failed to get the {key} environment variable"))
+}