Resource Management with Custom Drop Implementations in Rust

Rust's ownership system and borrowing rules are powerful tools for memory safety, but sometimes you need more control over resource cleanup than what the compiler automatically provides. This challenge focuses on implementing custom drop logic in Rust to reclaim resources beyond just memory, such as file handles, network connections, or mutex locks. You'll create a struct that manages a resource and define a Drop implementation to ensure that resource is properly released when the struct goes out of scope.

Problem Description

You are tasked with creating a ResourceGuard struct that manages a file descriptor. The ResourceGuard should take a file descriptor as input during construction and implement the Drop trait. The Drop implementation should close the file descriptor using the unistd::close function (you'll need to add unistd as a dependency). The goal is to demonstrate how to use the Drop trait to ensure resources are cleaned up automatically when an object is no longer needed, preventing resource leaks.

Key Requirements:

• Create a ResourceGuard struct that holds a file descriptor (i32).
• Implement the Drop trait for ResourceGuard.
• Within the drop method of ResourceGuard, call unistd::close on the file descriptor.
• Handle potential errors from unistd::close gracefully (e.g., by logging the error). Do not panic.
• Ensure the code compiles and runs without panicking.

Expected Behavior:

When a ResourceGuard instance goes out of scope, its drop method should be automatically called, closing the associated file descriptor. The program should not crash or leak file descriptors.

Edge Cases to Consider:

• What happens if the file descriptor is already closed or invalid when drop is called? The unistd::close function will return an error in this case. Your code should handle this error without panicking.
• Consider the order of operations if the ResourceGuard is dropped as part of a larger cleanup process.

Examples

Example 1:

Input: A valid file descriptor (e.g., 3)
Output: The file descriptor 3 is closed. No errors are printed to the console.
Explanation: A `ResourceGuard` is created with file descriptor 3. When the `ResourceGuard` goes out of scope, its `drop` method is called, which closes file descriptor 3.

Example 2:

Input: An invalid file descriptor (e.g., -1)
Output: An error message is printed to the console indicating that `unistd::close` failed. The program continues to execute.
Explanation: A `ResourceGuard` is created with an invalid file descriptor (-1). When the `ResourceGuard` goes out of scope, its `drop` method is called, which attempts to close the invalid file descriptor. `unistd::close` returns an error, which is handled gracefully.

Constraints

• The code must be written in Rust.
• You must use the unistd crate for the close function. Add unistd = "0.2" to your Cargo.toml dependencies.
• Error handling should avoid panics. Use println! to log errors.
• The solution should be concise and readable.
• The code must compile and run successfully.

Notes

• The Drop trait is automatically implemented for types that have a drop method.
• The drop method is called when a value goes out of scope.
• Consider using match or if let to handle the result of unistd::close.
• This exercise focuses on the core concept of custom drop implementations. More robust resource management often involves error propagation or more sophisticated cleanup strategies.