Asynchronous File Processing with async-std

This challenge focuses on utilizing the async-std library in Rust to perform asynchronous file reading and processing. Asynchronous operations are crucial for building responsive and efficient applications, especially when dealing with I/O-bound tasks like file manipulation. Your task is to create a program that reads a file line by line asynchronously, processes each line, and writes the processed lines to a new file, all without blocking the main thread.

Problem Description

You are tasked with creating a Rust program that reads a text file, converts each line to uppercase, and writes the uppercase versions to a new file. The program must leverage async-std for asynchronous file I/O to avoid blocking the main thread.

What needs to be achieved:

1. Read a text file specified by a command-line argument.
2. Asynchronously read the file line by line.
3. Convert each line to uppercase.
4. Asynchronously write the uppercase lines to a new file specified by another command-line argument.
5. Handle potential errors gracefully (e.g., file not found, permission errors).

Key Requirements:

• Use async-std::fs::File for asynchronous file operations.
• Use async-std::task to spawn asynchronous tasks.
• Use async-std::io::BufReader for efficient line-by-line reading.
• Use async-std::io::BufWriter for efficient line-by-line writing.
• Implement proper error handling using Result and ? operator.
• The program should accept the input and output file paths as command-line arguments.

Expected Behavior:

The program should take two command-line arguments: the input file path and the output file path. It should then read the input file asynchronously, convert each line to uppercase, and write the uppercase lines to the output file asynchronously. If any error occurs during the process (e.g., file not found, permission denied), the program should print an informative error message to the console and exit with a non-zero exit code. If the operation is successful, the program should exit with a zero exit code.

Edge Cases to Consider:

• Empty input file.
• Input file not found.
• Output file already exists (overwrite behavior).
• Permission errors when reading or writing files.
• Very large input files (consider memory usage).

Examples

Example 1:

Input: input.txt (containing "hello\nworld\n") output.txt
Output: output.txt (containing "HELLO\nWORLD\n")
Explanation: The program reads "hello" and "world" from input.txt, converts them to uppercase ("HELLO" and "WORLD"), and writes them to output.txt.

Example 2:

Input: non_existent_file.txt output.txt
Output: (Console output: "Error: File not found: non_existent_file.txt")
Explanation: The program attempts to open non_existent_file.txt, fails, prints an error message to the console, and exits with a non-zero exit code.

Example 3:

Input: input.txt output.txt
Output: output.txt (same content as input.txt if input.txt contains "hello\nworld\n" and no errors occur)
Explanation: The program reads, converts to uppercase, and writes back to the same file.

Constraints

• The input and output file paths will be provided as command-line arguments (strings).
• The input file will contain text data, potentially with multiple lines.
• The program must be able to handle files up to 10MB in size.
• The program should complete within 5 seconds for files up to 10MB.
• The program must compile and run without warnings.

Notes

• Consider using tokio::spawn or async_std::task::spawn to run the file reading and writing tasks concurrently.
• The to_uppercase() method on String can be used to convert a string to uppercase.
• Remember to handle potential errors when opening, reading, and writing files.
• Use async-std::process::exit to exit the program with a specific exit code.
• Think about how to efficiently buffer the file reading and writing operations to minimize system calls.