File Synchronization Tool

A File Synchronization Tool is a software utility designed to ensure that two or more locations (directories, drives, remote servers, or cloud storage) maintain an identical or consistent set of files. The primary goal is to keep data up-to-date across multiple storage points, facilitating data redundancy, backups, collaborative work, or simply ensuring that different devices (e.g., desktop, laptop) have the same files.

Core Concepts and Functionality:

1. Synchronization Types:
* One-Way (Mirroring): Changes made in a 'source' location are propagated to a 'destination' location. The destination becomes an exact replica of the source, and any changes made directly to the destination might be overwritten or ignored during the sync. This is commonly used for backups.
* Two-Way (Bidirectional): Changes made in either the source or destination location are propagated to the other, aiming to make both locations identical. This is more complex as it requires robust conflict resolution mechanisms.

2. Comparison and Detection:
Synchronization tools must efficiently detect differences between files and directories. Common methods include comparing:
* Modification Timestamps: The most common and fastest method. If a file's last modified time differs, it's considered changed.
* File Sizes: A quick check, but not foolproof (different content can have same size).
* File Hashes (Checksums): Cryptographic hashes (e.g., MD5, SHA-256) provide a highly reliable way to determine if file content has changed, even if timestamps are preserved. This is slower but more accurate.

3. Conflict Resolution (for Two-Way Sync):
When a file is modified in both the source and destination since the last synchronization, a conflict arises. Resolution strategies include:
* Keep Newest: The file with the latest modification timestamp wins.
* Keep Both: Rename one of the files (e.g., `filename (conflict copy).ext`).
* User Prompt: Ask the user to decide.
* Prefer Source/Destination: Always prioritize one location over the other.

4. Incremental Updates:
Instead of copying all files every time, synchronization tools only transfer new or changed files, significantly reducing sync time and bandwidth usage, especially for large datasets.

5. Deletion Handling:
* Propagate Deletions: If a file is deleted from the source, it's also deleted from the destination.
* Ignore Deletions: Deleted files in the source are not removed from the destination, often used in backup scenarios where accidental deletions need to be recoverable.

6. Error Handling:
Robust tools handle various errors gracefully, such as permission issues, locked files, disk full errors, network interruptions, and file corruption, often providing detailed logs.

7. Filters and Exclusions:
Users can often specify patterns (e.g., file extensions, directory names) to include or exclude certain files or folders from the synchronization process.

Common Use Cases:
* Backups: Creating redundant copies of important data.
* Data Migration: Moving large sets of files from one location to another while maintaining consistency.
* Collaboration: Sharing project files among team members, ensuring everyone has the latest versions.
* Device Synchronization: Keeping files consistent across a desktop, laptop, and mobile devices.
* Cloud Storage Integration: Syncing local files with cloud services like Dropbox, Google Drive, OneDrive.

Implementing a file synchronization tool requires careful consideration of file system interactions, performance optimization (especially for large numbers of files), and robust error handling to ensure data integrity.

```rust
use std::fs;
use std::path::{Path, PathBuf};
use std::io;

/// Performs a one-way synchronization from a source directory to a destination directory.
/// This function will:
/// 1. Create destination directories if they don't exist.
/// 2. Copy new files from source to destination.
/// 3. Update existing files in destination if the source file is newer.
///    (Based on last modification timestamp).
/// 4. Does NOT delete files from destination that are not present in source.
fn sync_directories(source: &Path, destination: &Path) -> io::Result<()> {
    println!("Synchronizing from {:?} to {:?}", source, destination);

    // Ensure the destination directory exists
    if !destination.exists() {
        fs::create_dir_all(destination)?;
        println!("Created destination directory: {:?}", destination);
    }

    // Read the source directory entries
    for entry_result in fs::read_dir(source)? {
        let entry = entry_result?;
        let source_path = entry.path();
        let relative_path = source_path.strip_prefix(source).map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
        let destination_path = destination.join(relative_path);

        if source_path.is_dir() {
            // Recursively sync subdirectories
            sync_directories(&source_path, &destination_path)?;
        } else if source_path.is_file() {
            let source_metadata = fs::metadata(&source_path)?;
            let source_modified = source_metadata.modified()?;

            let should_copy = if destination_path.exists() {
                let dest_metadata = fs::metadata(&destination_path)?;
                let dest_modified = dest_metadata.modified()?;
                source_modified > dest_modified
            } else {
                true // Destination file does not exist, so copy it
            };

            if should_copy {
                fs::copy(&source_path, &destination_path)?;
                println!("Copied/Updated: {:?} -> {:?}", source_path, destination_path);
            }
        } else {
            // Handle other types of files (symlinks, etc.) if necessary
            // For this example, we'll just skip them.
            println!("Skipping non-regular file/directory: {:?}", source_path);
        }
    }

    Ok(())
}

fn main() -> io::Result<()> {
    let args: Vec<String> = std::env::args().collect();

    if args.len() != 3 {
        eprintln!("Usage: {} <source_directory> <destination_directory>", args[0]);
        std::process::exit(1);
    }

    let source_dir = PathBuf::from(&args[1]);
    let dest_dir = PathBuf::from(&args[2]);

    if !source_dir.exists() {
        eprintln!("Error: Source directory does not exist: {:?}", source_dir);
        std::process::exit(1);
    }
    if !source_dir.is_dir() {
        eprintln!("Error: Source path is not a directory: {:?}", source_dir);
        std::process::exit(1);
    }

    println!("Starting file synchronization...");
    match sync_directories(&source_dir, &dest_dir) {
        Ok(_) => println!("Synchronization completed successfully."),
        Err(e) => eprintln!("Synchronization failed: {}", e),
    }

    Ok(())
}
```