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,9 @@ pub enum PackageManagerError {
         package: String,
         stderr: String,
     },
+    #[cfg(target_os = "linux")]
+    #[error("Failed to add LLVM PPA repository (for `apt`): {0}")]
+    LlvmPpaError(String),
 }
 
 pub trait PackageManager {
@@ -97,7 +100,7 @@ pub fn try_install_package(
                         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 super::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")]
@@ -134,13 +141,30 @@ 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)
+        } 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
+            {
+                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 +205,68 @@ impl PackageManager for UnixPackageManager {
         }
     }
 }
+
+#[cfg(target_os = "linux")]
+mod llvm_apt_install {
+    use super::super::{chmod, download};
+    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 = self.get_cache_dir().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 = self.has_sudo();
+
+        let output = if has_sudo {
+            Command::new("sudo").arg("bash")
+        } 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")