Merge pull request #1749 from Kobzol/src-change-defaults

Make it possible to run sync-team against local data

Author: marcoieni

.github/workflows/dry-run.yml

@@ -143,7 +143,7 @@ jobs:
           cargo build --release
           ./target/release/rust-team sync print-plan \
             --services github \
-            --team-json team-api 2>&1 | tee -a output.txt
+            --src team-api 2>&1 | tee -a output.txt
 
       - name: Prepare comment
         run: |

.github/workflows/main.yml

@@ -97,7 +97,7 @@ jobs:
           ZULIP_API_TOKEN: ${{ secrets.ZULIP_API_TOKEN }}
           ZULIP_USERNAME: ${{ secrets.ZULIP_USERNAME }}
         run: |
-          RUST_LOG="sync_team=debug" cargo run sync apply --team-json build
+          RUST_LOG="sync_team=debug" cargo run sync apply --src build
 
       - name: Disable Jekyll
         run: touch build/.nojekyll

Cargo.lock

@@ -20,6 +20,7 @@ serde = "1"
 serde_derive = "1"
 serde_json = "1"
 serde-untagged = "0.1"
+tempfile = "3.19.1"
 toml = "0.8"
 
 sync-team = { path = "sync-team" }

Cargo.toml

@@ -158,12 +158,11 @@ cargo run -- sync --services github,mailgun
 cargo run -- sync --services github,mailgun apply
 ```
 
-By default, the synchronization will be based on data from the live `team` endpoint.
-When making changes to the tool it might be useful to test
-with dummy data though. You can do that by passing the `--team-repo` flag to the CLI:
+By default, the synchronization will be based on data from the current `team` repository checkout.
+You can also perform the sync based on the live `team` endpoint using `--src=production`, or on an existing directory on disk that contains the prebuilt JSON files using `--src=<path>`.
 
 ```
-cargo run -- sync --team-json <directory>
+cargo run -- sync --src=<directory>
 ```
 
 The `<directory>` with JSON data can be generated using `cargo run static-api`.

README.md

@@ -25,6 +25,7 @@ use clap::Parser;
 use log::{error, info, warn};
 use std::collections::{BTreeMap, HashMap};
 use std::path::PathBuf;
+use std::str::FromStr;
 use sync_team::run_sync_team;
 use sync_team::team_api::TeamApi;
 
@@ -88,6 +89,9 @@ enum Cli {
     #[clap(subcommand)]
     Ci(CiOpts),
     /// Perform synchronization of the local data to live services.
+    /// By default, a dry-run against the local team repository data
+    /// is performed.
+    ///
     /// Environment variables:
     /// - GITHUB_TOKEN          Authentication token with GitHub
     /// - MAILGUN_API_TOKEN     Authentication token with Mailgun
@@ -114,19 +118,62 @@ struct SyncOpts {
     ), 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>,
-
+    /// Source of the data against which is the sync performed.
+    /// Possible values:
+    /// - in-tree => use the current team checkout
+    /// - production => use the live REST API team endpoint
+    /// - <path> => use prebuilt directory at <path>
+    #[arg(
+        long("src"),
+        global(true),
+        default_value = "in-tree",
+        verbatim_doc_comment
+    )]
+    source: DataSource,
+
+    /// Command that should be performed.
     #[clap(subcommand)]
     command: Option<SyncCommand>,
 }
 
-#[derive(clap::Parser, Debug)]
+#[derive(Clone, Debug)]
+enum DataSource {
+    /// Load data from the current `team` repo checkout.
+    InTree,
+    /// Load data from a prebuilt directory with JSON files.
+    Prebuilt {
+        /// Location of the directory.
+        path: PathBuf,
+    },
+    /// Load data from the production `team` REST API.
+    Production,
+}
+
+impl FromStr for DataSource {
+    type Err = String;
+
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        match input {
+            "in-tree" => Ok(Self::InTree),
+            "production" => Ok(Self::Production),
+            path => {
+                let path = PathBuf::from(path);
+                if path.is_dir() {
+                    Ok(Self::Prebuilt {
+                        path: PathBuf::from(path),
+                    })
+                } else {
+                    Err(
+                        "--src must be a path to an existing directory, `in-tree` or `production`"
+                            .to_string(),
+                    )
+                }
+            }
+        }
+    }
+}
+
+#[derive(clap::Parser, Clone, Debug)]
 enum SyncCommand {
     /// Try to apply changes, but do not send any outgoing API requests.
     DryRun,
@@ -451,7 +498,7 @@ fn run() -> Result<(), Error> {
             CiOpts::CheckCodeowners => check_codeowners(data)?,
         },
         Cli::Sync(opts) => {
-            if let Err(err) = perform_sync(opts) {
+            if let Err(err) = perform_sync(opts, data) {
                 // Display shows just the first element of the chain.
                 error!("failed: {}", err);
                 for cause in err.chain().skip(1) {
@@ -492,13 +539,19 @@ 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
+fn perform_sync(opts: SyncOpts, data: Data) -> anyhow::Result<()> {
+    // We pregenerate the directory here in case we need it, to make sure it lives
+    // long enough.
+    let source_dir = tempfile::tempdir()?;
+
+    let team_api = match opts.source {
+        DataSource::InTree => {
+            // Render the current data to a temporary directory
+            static_api::Generator::new(source_dir.path(), &data)?.generate()?;
+            TeamApi::Prebuilt(source_dir.path().to_path_buf())
+        }
+        DataSource::Prebuilt { path } => TeamApi::Prebuilt(path),
+        DataSource::Production => TeamApi::Production,
     };
 
     let mut services = opts.services;

src/main.rs

@@ -1,15 +1,12 @@
 use crate::utils::ResponseExt;
-use log::{debug, info, trace};
+use log::{debug, trace};
 use std::borrow::Cow;
 use std::path::PathBuf;
-use std::process::Command;
 
 /// Determines how do we get access to the ground-truth data from `rust-lang/team`.
 pub enum TeamApi {
     /// Access the live data from the published production REST API.
     Production,
-    /// Build the JSON data from a checkout of `rust-lang/team`.
-    Checkout(PathBuf),
     /// Directly access a directory with prebuilt JSON data.
     Prebuilt(PathBuf),
 }
@@ -62,28 +59,6 @@ impl TeamApi {
                     .error_for_status()?
                     .json_annotated()?)
             }
-            TeamApi::Checkout(path) => {
-                let dest = tempfile::tempdir()?;
-                info!(
-                    "generating the content of the Team API from {}",
-                    path.display()
-                );
-                let status = Command::new("cargo")
-                    .arg("run")
-                    .arg("--")
-                    .arg("static-api")
-                    .arg(dest.path())
-                    .env("RUST_LOG", "rust_team=warn")
-                    .current_dir(path)
-                    .status()?;
-                if status.success() {
-                    info!("contents of the Team API generated successfully");
-                    let contents = std::fs::read(dest.path().join("v1").join(url))?;
-                    Ok(serde_json::from_slice(&contents)?)
-                } else {
-                    anyhow::bail!("failed to generate the contents of the Team API");
-                }
-            }
             TeamApi::Prebuilt(directory) => {
                 let contents = std::fs::read(directory.join("v1").join(url))?;
                 Ok(serde_json::from_slice(&contents)?)