Arc<Mutex>

Guides

Rust walkthroughs

ā† Back to all guides

What is the difference between tempfile::TempDir and tempfile::tempdir_in for controlling temporary directory locations?

tempfile::TempDir is a type that manages a temporary directory with automatic cleanup, while tempdir_in is a function that creates a temporary directory in a specific location rather than the system default temporary directory. The key difference is control over where the temporary directory is created: tempdir() uses the system's default temporary directory (like /tmp on Unix), while tempdir_in(path) allows you to specify a custom parent directory. Both return TempDir values that automatically delete the directory when dropped.

Creating Temporary Directories with Default Location

use tempfile::tempdir;
 
fn main() -> std::io::Result<()> {
    // Creates a temporary directory in the system's default location
    // On Unix: usually /tmp
    // On Windows: usually %TEMP%
    let temp_dir = tempdir()?;
    
    println!("Created temp dir: {:?}", temp_dir.path());
    
    // The directory is automatically deleted when temp_dir goes out of scope
    // No manual cleanup needed
    
    Ok(())
}

tempdir() uses the system default temporary directory location.

Creating Temporary Directories in Custom Locations

use tempfile::tempdir_in;
use std::path::Path;
 
fn main() -> std::io::Result<()> {
    // Create temp dir in a specific location
    let custom_location = Path::new("./my_temp_dirs");
    std::fs::create_dir_all(custom_location)?;
    
    // tempdir_in creates the temp directory inside the specified path
    let temp_dir = tempdir_in(custom_location)?;
    
    println!("Created temp dir: {:?}", temp_dir.path());
    // Path will be something like: ./my_temp_dirs/tmp_randomstring
    
    // Still automatically cleaned up on drop
    Ok(())
}

tempdir_in gives you control over the parent directory for the temporary directory.

The TempDir Type

use tempfile::TempDir;
use std::path::PathBuf;
 
fn main() -> std::io::Result<()> {
    // Both tempdir() and tempdir_in() return TempDir
    let temp_dir: TempDir = tempfile::tempdir()?;
    
    // TempDir provides methods to work with the directory
    let path: &std::path::Path = temp_dir.path();
    println!("Path: {}", path.display());
    
    // Convert to PathBuf (consumes the TempDir, no automatic cleanup)
    let path_buf: PathBuf = temp_dir.into_path();
    println!("Consumed path: {}", path_buf.display());
    
    // Note: into_path() disables automatic cleanup
    // The directory will persist after the program ends
    
    Ok(())
}

TempDir is the return type for both functions, managing automatic cleanup.

Use Cases for tempdir_in

use tempfile::tempdir_in;
use std::path::Path;
 
fn main() -> std::io::Result<()> {
    // Use case 1: Disk space constraints
    // /tmp might be small, but /data has more space
    let temp_on_data = tempdir_in("/data/tmp")?;
    println!("Temp on data partition: {:?}", temp_on_data.path());
    
    // Use case 2: Security requirements
    // Create temp files on encrypted filesystem
    let encrypted_temp = tempdir_in("/encrypted/tmp")?;
    println!("Encrypted temp: {:?}", encrypted_temp.path());
    
    // Use case 3: Working directory proximity
    // Keep temp files near the project for easier debugging
    let project_temp = tempdir_in("./tmp")?;
    println!("Project temp: {:?}", project_temp.path());
    
    // Use case 4: Mounted filesystems
    // Use tmpfs for fast temporary storage
    let tmpfs_temp = tempdir_in("/dev/shm")?;
    println!("tmpfs temp: {:?}", tmpfs_temp.path());
    
    Ok(())
}

Control location based on disk space, security, or performance requirements.

Permissions and Security Implications

use tempfile::{tempdir, tempdir_in};
use std::fs;
 
fn main() -> std::io::Result<()> {
    // Default tempdir() uses system temp with standard permissions
    let default_temp = tempdir()?;
    
    // tempdir_in inherits permissions from parent directory
    // This can be important for:
    // - Confidential data (need restricted permissions)
    // - Shared workspaces (need group permissions)
    // - Network filesystems (need appropriate permissions)
    
    // Example: Create in a directory with specific permissions
    let custom_parent = Path::new("./secure_temp");
    fs::create_dir_all(custom_parent)?;
    
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        fs::set_permissions(custom_parent, fs::Permissions::from_mode(0o700))?;
    }
    
    let secure_temp = tempdir_in(custom_parent)?;
    println!("Secure temp: {:?}", secure_temp.path());
    
    Ok(())
}

Parent directory permissions affect security of temporary files.

Path Management and Persistence

use tempfile::{TempDir, tempdir_in};
use std::path::PathBuf;
 
fn process_files(input_dir: &std::path::Path) -> std::io::Result<()> {
    // Create temp directory near input for efficient processing
    let temp = tempdir_in(input_dir)?;
    
    // Work with files...
    let temp_file = temp.path().join("processed.txt");
    std::fs::write(&temp_file, "data")?;
    
    // Temp directory cleaned up automatically
    Ok(())
}
 
fn persistent_temp() -> std::io::Result<PathBuf> {
    let temp = tempdir_in("./work")?;
    
    // Convert to persistent path - disables cleanup
    let persistent_path = temp.into_path();
    
    // Now the directory won't be deleted automatically
    // Caller is responsible for cleanup
    
    Ok(persistent_path)
}
 
fn main() -> std::io::Result<()> {
    process_files(Path::new("./data"))?;
    
    let work_dir = persistent_temp()?;
    println!("Persistent work dir: {:?}", work_dir);
    
    // Need to manually clean up persistent_temp's directory
    // std::fs::remove_dir_all(&work_dir)?;
    
    Ok(())
}

into_path() converts to a persistent directory without automatic cleanup.

Error Handling Differences

use tempfile::{tempdir, tempdir_in};
use std::path::Path;
 
fn main() -> std::io::Result<()> {
    // tempdir() may fail if:
    // - System temp directory doesn't exist
    // - No write permissions to system temp
    // - Disk full
    
    match tempdir() {
        Ok(dir) => println!("Default temp: {:?}", dir.path()),
        Err(e) => {
            eprintln!("Failed to create default temp: {}", e);
            
            // Fallback to custom location
            let fallback = tempdir_in("./fallback")?;
            println!("Fallback temp: {:?}", fallback.path());
        }
    }
    
    // tempdir_in() may fail for additional reasons:
    // - Parent directory doesn't exist
    // - Invalid path
    // - Cross-filesystem issues
    
    let nonexistent = tempdir_in("/nonexistent/path");
    match nonexistent {
        Ok(_) => println!("Unexpected success"),
        Err(e) => println!("Expected error: {}", e),
    }
    
    Ok(())
}

tempdir_in has additional failure modes related to the specified parent directory.

Working with Files in TempDir

use tempfile::tempdir_in;
use std::fs::File;
use std::io::Write;
 
fn main() -> std::io::Result<()> {
    let temp_dir = tempdir_in("./work")?;
    
    // Create files inside the temp directory
    let file_path = temp_dir.path().join("output.txt");
    let mut file = File::create(&file_path)?;
    file.write_all(b"Hello, temp world!")?;
    
    // Create nested directories
    let nested_path = temp_dir.path().join("subdir/nested");
    std::fs::create_dir_all(&nested_path)?;
    
    let nested_file = nested_path.join("deep.txt");
    std::fs::write(&nested_file, "Nested content")?;
    
    println!("Temp directory: {:?}", temp_dir.path());
    println!("File exists: {}", file_path.exists());
    
    // All files are deleted when temp_dir is dropped
    Ok(())
}

TempDir automatically cleans up all contents, including nested structures.

Comparing tempdir() and tempdir_in()

use tempfile::{tempdir, tempdir_in};
 
fn main() -> std::io::Result<()> {
    // tempdir() - system default location
    // Pros:
    // - Simple, no path needed
    // - Uses system-configured temp location
    // - Automatically cleaned by OS on reboot (usually)
    // Cons:
    // - May have limited space
    // - May not meet security requirements
    // - May be slower (network filesystem)
    
    let system_temp = tempdir()?;
    println!("System temp: {:?}", system_temp.path());
    
    // tempdir_in() - custom location
    // Pros:
    // - Control over location
    // - Use appropriate filesystem for task
    // - Meet security/performance requirements
    // Cons:
    // - Parent directory must exist
    // - More error cases to handle
    // - Not cleaned by OS on reboot
    
    let custom_temp = tempdir_in("./local_temp")?;
    println!("Custom temp: {:?}", custom_temp.path());
    
    Ok(())
}

Choose based on requirements for location, space, security, and performance.

Builder Pattern for Advanced Configuration

use tempfile::Builder;
 
fn main() -> std::io::Result<()> {
    // Builder provides more control than tempdir_in alone
    let temp_dir = Builder::new()
        .prefix("myapp_")       // Prefix for directory name
        .suffix("_temp")        // Suffix for directory name
        .tempdir_in("./work")?;  // Custom location
    
    println!("Named temp dir: {:?}", temp_dir.path());
    // Path will be like: ./work/myapp_randomstring_temp
    
    // Control permissions (Unix only)
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        
        let secure_temp = Builder::new()
            .permissions(PermissionsExt::from_mode(0o700))
            .tempdir_in("./secure")?;
        
        println!("Secure temp: {:?}", secure_temp.path());
    }
    
    // Keep directory on errors for debugging
    let debug_temp = Builder::new()
        .keep(true)
        .tempdir_in("./debug")?;
    
    println!("Debug temp (kept): {:?}", debug_temp.path());
    
    Ok(())
}

Builder provides fine-grained control over temporary directory creation.

Testing with Controlled Locations

use tempfile::tempdir_in;
 
#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    
    #[test]
    fn test_file_operations() -> std::io::Result<()> {
        // Create test temp in project's test directory
        let test_temp = tempdir_in("./test_temp")?;
        
        // Test operations that create files
        let test_file = test_temp.path().join("test.txt");
        fs::write(&test_file, "test data")?;
        
        let content = fs::read_to_string(&test_file)?;
        assert_eq!(content, "test data");
        
        // Automatic cleanup after test
        Ok(())
    }
    
    #[test]
    fn test_large_files() -> std::io::Result<()> {
        // Use tempdir_in to test on filesystem with enough space
        let temp = tempdir_in("/data/test_temp")?;
        
        // Create large test files
        let large_file = temp.path().join("large.bin");
        let data = vec![0u8; 100_000_000];  // 100 MB
        fs::write(&large_file, &data)?;
        
        assert!(large_file.exists());
        Ok(())
    }
}

Tests benefit from controlled temp locations for reproducibility and cleanup.

Resource Cleanup Semantics

use tempfile::{TempDir, tempdir_in};
 
fn main() -> std::io::Result<()> {
    // Normal cleanup - happens on drop
    {
        let temp = tempdir_in("./work")?;
        let file_path = temp.path().join("file.txt");
        std::fs::write(&file_path, "data")?;
        
        println!("File exists: {}", file_path.exists());
        
        // temp is dropped here
        // Directory and file are deleted
    }
    
    // Manual cleanup before drop
    {
        let temp = tempdir_in("./work")?;
        std::fs::write(temp.path().join("file.txt"), "data")?;
        
        // Explicit cleanup
        temp.close()?;  // Consumes TempDir, cleans up
        
        // temp is no longer accessible
    }
    
    // Disable cleanup
    {
        let temp = tempdir_in("./work")?;
        std::fs::write(temp.path().join("file.txt"), "data")?;
        
        let persistent_path = temp.into_path();
        
        // Directory persists
        println!("Persistent path: {:?}", persistent_path);
        
        // Manual cleanup needed later
        std::fs::remove_dir_all(&persistent_path)?;
    }
    
    Ok(())
}

Three cleanup options: automatic (drop), manual (close()), or disabled (into_path()).

Handling Cleanup Errors

use tempfile::tempdir_in;
use std::io;
 
fn main() -> io::Result<()> {
    let temp = tempdir_in("./work")?;
    
    // Create some files
    std::fs::write(temp.path().join("file.txt"), "data")?;
    
    // close() returns Result, allowing error handling
    // drop() silently ignores cleanup errors
    match temp.close() {
        Ok(()) => println!("Cleanup successful"),
        Err(e) => {
            eprintln!("Cleanup failed: {}", e);
            // May happen if:
            // - Files are still open
            // - Permission issues
            // - Directory was manually deleted
            
            // Handle appropriately
        }
    }
    
    // Alternative: use drop and accept silent failure
    let temp2 = tempdir_in("./work")?;
    std::fs::write(temp2.path().join("file.txt"), "data")?;
    
    // Cleanup errors are logged but don't panic
    // drop(temp2);
    
    Ok(())
}

close() handles cleanup errors; drop() silently ignores them.

Synthesis

Quick reference:

use tempfile::{tempdir, tempdir_in, TempDir, Builder};
 
fn main() -> std::io::Result<()> {
    // tempdir() - system default location
    let default_temp = tempdir()?;
    println!("Default: {:?}", default_temp.path());
    
    // tempdir_in() - custom location
    let custom_temp = tempdir_in("./my_temp")?;
    println!("Custom: {:?}", custom_temp.path());
    
    // Both return TempDir
    let temp: TempDir = tempdir_in("./work")?;
    
    // TempDir methods:
    // - path() -> &Path: Get directory path
    // - into_path() -> PathBuf: Disable cleanup, get owned path
    // - close() -> Result<()>: Manual cleanup with error handling
    
    // Builder for advanced configuration
    let configured = Builder::new()
        .prefix("app_")
        .suffix("_tmp")
        .tempdir_in("./work")?;
    
    println!("Configured: {:?}", configured.path());
    
    // Key differences:
    // tempdir():
    // - Uses system temp directory
    // - Simpler API
    // - Respects system configuration
    
    // tempdir_in():
    // - Custom parent directory
    // - Control over location
    // - Parent must exist
    // - More error cases
    
    // Use tempdir_in when:
    // - System temp has insufficient space
    // - Need specific filesystem (speed/security)
    // - Working with large files
    // - Need temp files near source data
    // - Security requires specific location
    
    Ok(())
}

Key insight: Both tempdir() and tempdir_in() return the same TempDir type with identical cleanup semanticsā€”the difference is purely about where the temporary directory is created. tempdir() uses the system default (like /tmp on Unix), which is fine for most cases but may fail for large files, encrypted storage requirements, or when you need files near your project. tempdir_in(path) lets you specify a custom parent directory, giving you control over disk space, filesystem type, and security characteristics. Use Builder when you need even more control over directory names, permissions, or cleanup behavior. The TempDir type handles automatic cleanup through RAIIā€”either silently on drop or explicitly with error handling via close(). Use into_path() when you need the directory to persist after the program ends.