Merge "Refactor import logic to make missing license files recoverable." into main

Author: Treehugger Robot

tools/external_crates/crate_tool/src/managed_repo.rs

@@ -16,10 +16,9 @@ use std::{
     cell::OnceCell,
     collections::BTreeSet,
     env,
-    fs::{create_dir, create_dir_all, read_dir, write},
+    fs::{create_dir_all, read_dir, write},
     os::unix::fs::symlink,
     path::Path,
-    process::Command,
 };
 
 use anyhow::{anyhow, bail, Context, Result};
@@ -32,7 +31,6 @@ use repo_config::RepoConfig;
 use rooted_path::RootedPath;
 use semver::{Version, VersionReq};
 use serde::Serialize;
-use spdx::Licensee;
 
 use crate::{
     android_bp::cargo_embargo_autoconfig,
@@ -268,52 +266,6 @@ impl ManagedRepo {
         println!("  Finding license files");
         let licenses = find_licenses(krate.path().abs(), krate.name(), krate.license())?;
 
-        if !licenses.unsatisfied.is_empty() && licenses.satisfied.is_empty() {
-            let mut satisfied = false;
-            // Sometimes multiple crates live in a single GitHub repo. A common case
-            // is a crate with an associated proc_macro crate. In such cases, the individual
-            // crates are in subdirectories with license files at root of the repo, and
-            // the license files don't get distributed with the crates.
-            // So, if we didn't find a license file, try to guess the URL of the appropriate
-            // license file and download it. This is incredibly hacky, and only supports
-            // the most common case, which is LICENSE-APACHE.
-            if licenses.unsatisfied.len() == 1 {
-                let req = licenses.unsatisfied.first().unwrap();
-                if let Some(repository) = krate.repository() {
-                    if *req == Licensee::parse("Apache-2.0").unwrap().into_req() {
-                        let url = format!("{}/master/LICENSE-APACHE", repository);
-                        let body = reqwest::blocking::get(
-                            url.replace("github.com", "raw.githubusercontent.com"),
-                        )?
-                        .text()?;
-                        write(krate.path().abs().join("LICENSE"), body)?;
-                        let patch_dir = krate.path().abs().join("patches");
-                        create_dir(&patch_dir)?;
-                        let output = Command::new("diff")
-                            .args(["-u", "/dev/null", "LICENSE"])
-                            .current_dir(krate.path().abs())
-                            .output()?;
-                        write(patch_dir.join("LICENSE.patch"), output.stdout)?;
-                        satisfied = true;
-                    }
-                }
-            }
-            if !satisfied {
-                return Err(anyhow!(
-                    "Could not find license files for all licenses. Missing {}",
-                    licenses.unsatisfied.iter().join(", ")
-                ));
-            }
-        }
-
-        // If there's a single applicable license file, symlink it to LICENSE.
-        if licenses.satisfied.len() == 1 && licenses.unsatisfied.is_empty() {
-            let license_file = krate.path().join("LICENSE")?;
-            if !license_file.abs().exists() {
-                symlink(licenses.satisfied.iter().next().unwrap().1, license_file)?;
-            }
-        }
-
         update_module_license_files(&krate.path().abs(), &licenses)?;
 
         println!("  Creating METADATA");
@@ -335,12 +287,45 @@ impl ManagedRepo {
         } else {
             write(krate.path().abs().join("cargo_embargo.json"), "{}")?;
         }
-        // Workaround. Our logic for crate health assumes the crate isn't healthy if there's
-        // no Android.bp. So create an empty one.
-        write(krate.path().abs().join("Android.bp"), "")?;
 
-        self.regenerate([&crate_name].iter())?;
-        println!("Please edit {} and run 'regenerate' for this crate", managed_dir);
+        // If there's a single applicable license file, symlink it to LICENSE.
+        // TODO: Move this logic into regenerate, and improve it.
+        if licenses.satisfied.len() == 1 && licenses.unsatisfied.is_empty() {
+            let license_file = krate.path().join("LICENSE")?;
+            if !license_file.abs().exists() {
+                symlink(licenses.satisfied.iter().next().unwrap().1, license_file)?;
+            }
+        }
+
+        if !licenses.unsatisfied.is_empty() {
+            println!(
+                r#"
+Unable to find license files for the following license terms: {:?}
+
+Please look in {managed_dir} and try to locate the license file
+
+If you find the license file:
+* That means there's a bug in our detection logic.
+* Please file a bug at http://go/android-rust-crate-bug
+
+If you can't find the license file:
+* This is usually because the source repo for the crate contains several crates in
+  separate directories, with a license file at the root level that's not included in
+  each crate
+* Please go to the upstream repo for the crate at {}
+* Download the license file and create a patch for it. Instructions for creating patches
+  are at https://android.googlesource.com/platform/external/rust/android-crates-io/+/refs/heads/main/README.md#how-to-add-a-patch-file
+* Run `crate_tool regenerate {}` after you have added a patch for the license file
+
+We apologize for the inconvenience."#,
+                licenses.unsatisfied.iter().map(|u| u.to_string()).join(", "),
+                krate.repository().unwrap_or("(Crate repository URL not found in Cargo.toml)"),
+                krate.name()
+            );
+        } else {
+            self.regenerate([&crate_name].iter())?;
+            println!("Please edit {} and run 'regenerate' for this crate", managed_dir);
+        }
 
         Ok(())
     }