Add directory walk to find qt artifacts

Author: BenFordTytherington

Cargo.lock

@@ -27,7 +27,7 @@ members = [
 
     "tests/basic_cxx_only/rust",
     "tests/basic_cxx_qt/rust",
-    "tests/qt_types_standalone/rust",
+    "tests/qt_types_standalone/rust", "examples/qt_minimal",
 ]
 resolver = "2"
 

Cargo.toml

@@ -3,9 +3,10 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use std::path::{Path, PathBuf};
-
+use semver::Version;
 use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::time::Duration;
 
 #[derive(Debug, Serialize, Deserialize)]
 /// A Qt manifest.json file, which specifies a set of artifacts needed for installation
@@ -17,7 +18,7 @@ pub(crate) struct ParsedQtManifest {
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
 /// Descriptor for a Qt artifact, included download information
 pub(crate) struct ParsedQtArtifact {
-    pub(crate) version: semver::Version,
+    pub(crate) version: Version,
     pub(crate) arch: String,
     pub(crate) os: String,
     pub(crate) url: String,
@@ -29,7 +30,10 @@ impl ParsedQtArtifact {
     /// Download the artifact and extract to the given target path
     pub fn download_and_extract(&self, target_path: &Path) -> PathBuf {
         // Download to a temporary location
-        let http_client = reqwest::blocking::Client::new();
+        let http_client = reqwest::blocking::Client::builder()
+            .timeout(None)
+            .build()
+            .expect("Http client failed to build");
         let temp_dir = tempfile::TempDir::new().expect("Could not create temporary directory");
         let archive_path =
             super::download::download_from_url(&self.url, &self.sha256, &temp_dir, &http_client)
@@ -46,6 +50,23 @@ impl ParsedQtArtifact {
         target_path.to_path_buf()
     }
 
+    pub fn new(
+        version: Version,
+        arch: String,
+        os: String,
+        url: String,
+        content_type: String,
+    ) -> Self {
+        Self {
+            version,
+            arch,
+            os,
+            url,
+            sha256: "".to_string(),
+            content: vec![content_type],
+        }
+    }
+
     /// Assert that the hashes are the same, from bytes
     pub fn verify(&self, hash: &[u8]) -> anyhow::Result<()> {
         let mut hash_string = String::new();

crates/qt-build-utils/src/installation/qt_minimal/artifact.rs

@@ -8,8 +8,10 @@ mod checksum;
 mod download;
 mod extract;
 
-use std::path::PathBuf;
+use std::fs::DirEntry;
+use std::path::{Path, PathBuf};
 
+use crate::installation::qt_minimal::artifact::ParsedQtArtifact;
 use crate::{QtBuildError, QtInstallation};
 
 /// A implementation of [QtInstallation] using qtminimal
@@ -42,7 +44,7 @@ impl TryFrom<semver::Version> for QtInstallationQtMinimal {
         let os = target_parts
             .get(2)
             .expect("TARGET to have a <sys> component");
-        let artifacts: Vec<artifact::ParsedQtArtifact> = manifest
+        let artifacts: Vec<ParsedQtArtifact> = manifest
             .artifacts
             .into_iter()
             .filter(|artifact| {
@@ -73,6 +75,8 @@ impl TryFrom<semver::Version> for QtInstallationQtMinimal {
             artifact_include.download_and_extract(&extract_target_dir);
         }
 
+        println!(">>>> Artefacts: {:?}", Self::local_artifacts());
+
         Ok(Self {
             path_qt: extract_target_dir.join("qt"),
             version,
@@ -148,4 +152,69 @@ impl QtInstallationQtMinimal {
 
         path
     }
+
+    /// Get a collection of the locally installed Qt artifacts
+    fn local_artifacts() -> anyhow::Result<Vec<ParsedQtArtifact>> {
+        let base_dir = Self::qt_minimal_root();
+
+        let mut artifacts = vec![];
+
+        // Iterate versions
+        for version in list_dirs(&base_dir) {
+            let path = version;
+            let semver = semver::Version::parse(path.file_name().to_str().unwrap())
+                .expect("Could not parse semver from directory name");
+
+            for os in list_dirs(&path.path()) {
+                let path = os;
+                let os = path.file_name().to_str().unwrap().to_string();
+
+                for arch in list_dirs(&path.path()) {
+                    let path = arch;
+                    let dir_entries = list_dirs(&path.path());
+
+                    // Expects one qt dir
+                    let qt_dir_path = dir_entries
+                        .iter()
+                        .filter(|dir| dir.file_name() == "qt")
+                        .last()
+                        .expect("Expected to find a Qt dir in this folder");
+
+                    let qt_folders = list_dirs(&qt_dir_path.path());
+                    for dir in qt_folders {
+                        let filename = dir.file_name();
+                        // Will be set if bin or include dirs are found
+                        let mut artifact_type = None;
+
+                        if filename == "bin" {
+                            artifact_type = Some("bin");
+                        } else if filename == "include" {
+                            artifact_type = Some("include");
+                        }
+
+                        if let Some(artifact_type) = artifact_type {
+                            artifacts.push(ParsedQtArtifact::new(
+                                semver.clone(),
+                                path.file_name().to_string_lossy().to_string(),
+                                os.clone(),
+                                qt_dir_path.path().to_string_lossy().to_string(),
+                                artifact_type.to_string(),
+                            ))
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(artifacts)
+    }
+}
+
+/// Get all valid directories in path bufs, ignoring errors
+fn list_dirs(path: &PathBuf) -> Vec<DirEntry> {
+    path.read_dir()
+        .unwrap()
+        .filter(|d| d.is_ok())
+        .map(|d| d.unwrap())
+        .collect()
 }

crates/qt-build-utils/src/installation/qt_minimal/mod.rs

@@ -0,0 +1,16 @@
+[package]
+name = "qt_minimal"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+version.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+
+[build-dependencies]
+semver.workspace = true
+qt-build-utils = { workspace = true, features = ["qt_minimal"] }
+
+[lints]
+workspace = true

examples/qt_minimal/Cargo.toml

@@ -0,0 +1,13 @@
+use qt_build_utils::{QtInstallation, QtInstallationQtMinimal};
+
+fn main() {
+    println!("qt_minimal auto download, asking for 6.10.0");
+    let install = QtInstallationQtMinimal::try_from(semver::Version::new(6, 10, 0)).unwrap();
+    println!("Found Qt install: {}", install.version());
+    println!(
+        "Discovered include path: {:?}",
+        install.include_paths(&vec![])
+    );
+    let moc = install.try_find_tool(qt_build_utils::QtTool::Moc).unwrap();
+    println!("Found moc: {}", moc.display());
+}

examples/qt_minimal/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}