src/context/local.rs

@@ -4,6 +4,7 @@ use super::api::ContextDriver;
 use std::io;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::time::SystemTime;
 
 pub struct LocalDriver;
 
@@ -20,8 +21,34 @@ impl ContextDriver for LocalDriver {
     }
 
     fn create_temp_dir(&self) -> io::Result<String> {
-        let temp_dir = tempfile::Builder::new().prefix("pkh-").tempdir()?;
+        // Generate a unique temporary directory name with random string
-        Ok(temp_dir.keep().to_string_lossy().to_string())
+        let base_timestamp = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+
+        let mut attempt = 0;
+        loop {
+            let work_dir_name = if attempt == 0 {
+                format!("pkh-{}", base_timestamp)
+            } else {
+                format!("pkh-{}-{}", base_timestamp, attempt)
+            };
+
+            let temp_dir_path = std::env::temp_dir().join(&work_dir_name);
+
+            // Check if directory already exists
+            if temp_dir_path.exists() {
+                attempt += 1;
+                continue;
+            }
+
+            // Create the directory
+            std::fs::create_dir_all(&temp_dir_path)?;
+
+            // Return the path as a string
+            return Ok(temp_dir_path.to_string_lossy().to_string());
+        }
     }
 
     fn retrieve_path(&self, src: &Path, dest: &Path) -> io::Result<()> {

src/context/unshare.rs

@@ -112,27 +112,41 @@ impl ContextDriver for UnshareDriver {
     }
 
     fn create_temp_dir(&self) -> io::Result<String> {
-        // Create a temporary directory inside the chroot
+        // Create a temporary directory inside the chroot with unique naming
-        let timestamp = std::time::SystemTime::now()
+        let base_timestamp = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap()
             .as_secs();
 
-        let work_dir_name = format!("pkh-build-{}", timestamp);
+        let mut attempt = 0;
-        let work_dir_inside_chroot = format!("/tmp/{}", work_dir_name);
+        loop {
+            let work_dir_name = if attempt == 0 {
+                format!("pkh-build-{}", base_timestamp)
+            } else {
+                format!("pkh-build-{}-{}", base_timestamp, attempt)
+            };
 
-        // Create the directory on the host filesystem
+            let work_dir_inside_chroot = format!("/tmp/{}", work_dir_name);
-        let host_path = Path::new(&self.path).join("tmp").join(&work_dir_name);
+            let host_path = Path::new(&self.path).join("tmp").join(&work_dir_name);
-        std::fs::create_dir_all(&host_path)?;
 
-        debug!(
+            // Check if directory already exists
-            "Created work directory: {} (host: {})",
+            if host_path.exists() {
-            work_dir_inside_chroot,
+                attempt += 1;
-            host_path.display()
+                continue;
-        );
+            }
 
-        // Return the path as it appears inside the chroot
+            // Create the directory on the host filesystem
-        Ok(work_dir_inside_chroot)
+            std::fs::create_dir_all(&host_path)?;
+
+            debug!(
+                "Created work directory: {} (host: {})",
+                work_dir_inside_chroot,
+                host_path.display()
+            );
+
+            // Return the path as it appears inside the chroot
+            return Ok(work_dir_inside_chroot);
+        }
     }
 
     fn copy_path(&self, src: &Path, dest: &Path) -> io::Result<()> {

src/deb/mod.rs

@@ -159,11 +159,11 @@ mod tests {
         );
     }
 
-    // #[tokio::test]
+    #[tokio::test]
-    // #[test_log::test]
+    #[test_log::test]
-    // async fn test_deb_hello_ubuntu_end_to_end() {
+    async fn test_deb_hello_ubuntu_end_to_end() {
-    //     test_build_end_to_end("hello", "noble", None, None, false).await;
+        test_build_end_to_end("hello", "noble", None, None, false).await;
-    // }
+    }
 
     #[tokio::test]
     #[test_log::test]