add fallback to LLVM install script (for apt)

and conditionally use `sudo`

Author: 2bndy5

clang-installer/src/downloader/mod.rs

@@ -72,6 +72,27 @@ async fn download(url: &Url, cache_path: &Path, timeout: u64) -> Result<(), Down
     Ok(())
 }
 
+/// On Unix-like systems, this changes the permissions of the file at `path`.
+///
+/// If `mode` is `Some`, then the permissions will be set to the bitwise OR of
+/// the existing permissions and given `mode`.
+/// If `mode` is `None`, then the permissions will be set to `0o755`.
+#[cfg(unix)]
+fn chmod_file(path: &Path, mode: Option<u32>) -> std::io::Result<()> {
+    // Make the extracted binary executable on Unix-like systems.
+    use std::os::unix::fs::PermissionsExt;
+    let out = fs::OpenOptions::new().write(true).open(path)?;
+    let mut perms = out.metadata()?.permissions();
+    match mode {
+        Some(mode) => {
+            let prev = perms.mode();
+            perms.set_mode(prev | mode);
+        }
+        None => perms.set_mode(0o755),
+    }
+    out.set_permissions(perms)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::DownloadError;

clang-installer/src/downloader/native_packages/mod.rs

@@ -20,6 +20,13 @@ pub enum PackageManagerError {
         package: String,
         stderr: String,
     },
+    #[cfg(target_os = "linux")]
+    #[error("Failed to add LLVM PPA repository (for `apt`): {0}")]
+    LlvmPpaError(String),
+    #[error("Failed parsing URL: {0}")]
+    UrlParseError(#[from] url::ParseError),
+    #[error(transparent)]
+    DownloadError(#[from] crate::downloader::DownloadError),
 }
 
 pub trait PackageManager {
@@ -46,7 +53,7 @@ pub trait PackageManager {
         &self,
         package_name: &str,
         version: Option<&Version>,
-    ) -> Result<(), PackageManagerError>;
+    ) -> impl Future<Output = Result<(), PackageManagerError>>;
 }
 
 pub fn get_available_package_managers() -> Vec<impl PackageManager + Display> {
@@ -63,7 +70,7 @@ pub fn get_available_package_managers() -> Vec<impl PackageManager + Display> {
     managers
 }
 
-pub fn try_install_package(
+pub async fn try_install_package(
     tool: &ClangTool,
     version_req: &VersionReq,
     min_version: &Version,
@@ -92,12 +99,13 @@ pub fn try_install_package(
                 log::info!(
                     "{mgr} package manager does not have a version of {tool} matching {version_req} installed."
                 );
-                match mgr.install_package(&pkg_name, Some(min_version)) {
+                match mgr.install_package(&pkg_name, Some(min_version)).await {
                     Ok(()) => {
                         log::info!(
                             "Successfully installed {tool} v{min_version} using {mgr} package manager."
                         );
-                        let path = tool.get_exe_path(&RequestedVersion::SystemDefault)?;
+                        let path =
+                            tool.get_exe_path(&RequestedVersion::Requirement(version_req.clone()))?;
                         let version = tool.capture_version(&path)?;
                         if version_req.matches(&version) {
                             log::info!(

clang-installer/src/downloader/native_packages/unix.rs

@@ -36,6 +36,9 @@ impl Display for UnixPackageManager {
     }
 }
 
+#[cfg(target_os = "linux")]
+impl crate::downloader::caching::Cacher for UnixPackageManager {}
+
 impl UnixPackageManager {
     fn as_str(&self) -> &'static str {
         match self {
@@ -49,6 +52,10 @@ impl UnixPackageManager {
         }
     }
 
+    fn has_sudo() -> bool {
+        which::which("sudo").is_ok()
+    }
+
     fn pkg_name_with_version(&self, package_name: &str, version: Option<&Version>) -> String {
         match self {
             #[cfg(target_os = "linux")]
@@ -114,7 +121,7 @@ impl PackageManager for UnixPackageManager {
         }
     }
 
-    fn install_package(
+    async fn install_package(
         &self,
         package_name: &str,
         version: Option<&Version>,
@@ -134,13 +141,37 @@ impl PackageManager for UnixPackageManager {
                 args.push("install");
             }
         }
-        let output = Command::new(self.as_str())
-            .args(args)
-            .arg(package_id.as_str())
-            .output()?;
+        let output = if Self::has_sudo() {
+            Command::new("sudo")
+                .arg(self.as_str())
+                .args(args)
+                .arg(package_id.as_str())
+                .output()?
+        } else {
+            Command::new(self.as_str())
+                .args(args)
+                .arg(package_id.as_str())
+                .output()?
+        };
         if output.status.success() {
             Ok(())
         } else {
+            #[cfg(target_os = "linux")]
+            if matches!(self, UnixPackageManager::Apt)
+                && let Some(version) = version
+            {
+                use crate::downloader::caching::Cacher;
+
+                log::info!(
+                    "trying to install from official LLVM PPA repository (for Debian-based `apt` package manager)"
+                );
+                return llvm_apt_install::install_llvm_via_apt(
+                    Self::get_cache_dir().as_path(),
+                    version.major.to_string(),
+                    package_id.as_str(),
+                )
+                .await;
+            }
             Err(PackageManagerError::InstallationError {
                 manager: self.as_str().to_string(),
                 package: package_id,
@@ -181,3 +212,75 @@ impl PackageManager for UnixPackageManager {
         }
     }
 }
+
+#[cfg(target_os = "linux")]
+mod llvm_apt_install {
+    use crate::downloader::{
+        chmod_file, download,
+        native_packages::{PackageManagerError, unix::UnixPackageManager},
+    };
+    use std::{path::Path, process::Command};
+    use url::Url;
+
+    const LLVM_INSTALL_SCRIPT_URL: &str = "https://apt.llvm.org/llvm.sh";
+
+    /// Installs the official LLVM APT repository and its GPG key.
+    ///
+    /// This is required to install specific versions of clang tools on Debian-based distributions using `apt`.}
+    pub async fn install_llvm_via_apt(
+        cache_path: &Path,
+        ver_major: String,
+        package_name: &str,
+    ) -> Result<(), PackageManagerError> {
+        let download_path = cache_path.join("llvm_apt_install.sh");
+        if !download_path.exists() {
+            log::info!(
+                "Downloading LLVM APT repository installation script from {LLVM_INSTALL_SCRIPT_URL}"
+            );
+            download(
+                &Url::parse(LLVM_INSTALL_SCRIPT_URL)?,
+                &download_path,
+                60 * 2,
+            )
+            .await?;
+            chmod_file(&download_path, Some(0o111))?;
+        }
+        let has_sudo = UnixPackageManager::has_sudo();
+
+        let output = if has_sudo {
+            Command::new("sudo")
+                .arg("bash")
+                .arg(download_path.as_os_str())
+                .arg(ver_major)
+                .output()?
+        } else {
+            Command::new("bash")
+                .arg(download_path.as_os_str())
+                .arg(ver_major)
+                .output()?
+        };
+        if !output.status.success() {
+            return Err(PackageManagerError::LlvmPpaError(
+                String::from_utf8_lossy(&output.stderr).to_string(),
+            ));
+        }
+        let output = if has_sudo {
+            Command::new("sudo")
+                .arg("apt")
+                .args(["install", "-y", package_name])
+                .output()
+        } else {
+            Command::new("apt")
+                .args(["install", "-y", package_name])
+                .output()
+        }?;
+        if !output.status.success() {
+            return Err(PackageManagerError::InstallationError {
+                manager: "apt (with LLVM PPA)".to_string(),
+                package: package_name.to_string(),
+                stderr: String::from_utf8_lossy(&output.stderr).to_string(),
+            });
+        }
+        Ok(())
+    }
+}

clang-installer/src/downloader/static_dist.rs

@@ -151,14 +151,7 @@ impl StaticDistDownloader {
             log::info!("Downloading static binary for {tool} version {ver_str} from {url}");
             download(&url, &download_path, 60 * 2).await?;
             #[cfg(unix)]
-            {
-                // Make the extracted binary executable on Unix-like systems.
-                use std::os::unix::fs::PermissionsExt;
-                let out = fs::OpenOptions::new().write(true).open(&download_path)?;
-                let mut perms = out.metadata()?.permissions();
-                perms.set_mode(0o755);
-                out.set_permissions(perms)?;
-            }
+            super::chmod_file(&download_path, None)?;
         }
         let sha512_cache_path = cache_path
             .join("static_dist")

clang-installer/src/version.rs

@@ -139,7 +139,9 @@ impl RequestedVersion {
                     Ok(bin) => bin,
                     Err(e) => {
                         log::error!("Failed to download {tool} {version_req} from PyPi: {e}");
-                        if let Some(result) = try_install_package(tool, version_req, &min_ver)? {
+                        if let Some(result) =
+                            try_install_package(tool, version_req, &min_ver).await?
+                        {
                             return Ok(Some(result));
                         }
                         log::info!("Falling back to downloading {tool} static binaries.");