storage_latest.rs

Overview

This file defines functionality to handle HTTP requests that retrieve the most recently modified file from a given storage directory. It contains the StorageLatestHandler struct which implements the Handler trait from the HTTP framework used, enabling it to serve as an endpoint handler. When triggered, it locates the latest file in the configured storage directory and responds with an HTTP temporary redirect to the path of this file, facilitating client access to the newest stored resource.

Structs and Implementations

StorageLatestHandler

• Purpose: Encapsulates the storage directory path and provides the handler implementation to serve the latest file.

• Fields:

  • storage_dir: PathBuf — The file system path to the directory containing stored files.

Methods

• new(storage_dir: PathBuf) -> Self

  Constructs a new instance of StorageLatestHandler with the specified directory path.

  Parameters:

  • storage_dir — The directory where files are stored.

  Returns:

  • A new StorageLatestHandler instance.

  Usage example:

  let handler = StorageLatestHandler::new(PathBuf::from("/path/to/storage"));
  

Handler Trait Implementation for StorageLatestHandler

This implementation defines the asynchronous handle method, which is invoked on an incoming HTTP request.

• async fn handle(&self, _req: &mut Request, _depot: &mut Depot, res: &mut Response, _ctrl: &mut FlowCtrl)

  Handles the HTTP request by determining the latest file in the storage directory and responding with an HTTP redirect to that file's URL.

  Parameters:

  • _req: &mut Request — The HTTP request object. Not used in this handler.

  • _depot: &mut Depot — Shared state object. Not used here.

  • res: &mut Response — The HTTP response object to be populated.

  • _ctrl: &mut FlowCtrl — Controls flow of the request processing. Not used here.

  Behavior:

  • Calls get_latest_file to find the newest file.

  • On success, responds with a temporary redirect (HTTP 307) to /v2/storage/{file_name}.

  • On failure (e.g., no files found or directory read error), sets HTTP status to 404 Not Found and responds with an error message.

  Usage Scenario:
  This method is typically invoked by the HTTP framework when a request arrives at the route bound to this handler, providing clients with the most up-to-date resource.

Functions

get_latest_file(storage_dir: &PathBuf) -> anyhow::Result<String>

• Purpose: Finds the most recently modified regular file in the specified directory.

• Parameters:

  • storage_dir — A reference to a PathBuf representing the directory to scan.

• Returns:

  • Ok(String) containing the filename of the latest modified file.

  • Err(anyhow::Error) if the directory cannot be read or if no files are found.

• Implementation Details:

  • Reads the directory entries with std::fs::read_dir.

  • Filters entries to include only regular files.

  • Extracts the modified timestamp metadata and filters out entries with inaccessible metadata.

  • Uses max_by_key on the modification times to select the newest file.

  • Converts the filename from OsString to a UTF-8 String using to_string_lossy.

  • Returns an error if no files are present.

• Usage Example:

  match get_latest_file(&PathBuf::from("/path/to/storage")) {
      Ok(file_name) => println!("Latest file: {}", file_name),
      Err(e) => eprintln!("Error: {}", e),
  }
  

Implementation Details and Algorithms

The core algorithm to find the latest file is performed in get_latest_file. It leverages Rust's filesystem APIs to:

1. Enumerate directory entries.

2. Filter to only regular files by checking their metadata.

3. Extract modification timestamps, gracefully handling errors by discarding entries with inaccessible metadata.

4. Identify the maximum modification timestamp using max_by_key.

5. Convert the resulting filename to a string for use in HTTP redirection.

The handler StorageLatestHandler then uses this function to obtain the filename and sends an HTTP redirect response to effectively forward the client to the latest stored resource.

Interaction with Other Components

• This handler is designed to be plugged into an HTTP server framework that uses the Handler trait from salvo::prelude::*.

• The handle method interacts with HTTP request (Request), response (Response), and control flow (FlowCtrl) abstractions provided by the framework.

• The redirect response points clients to /v2/storage/{file_name}, implying the existence of another route or handler responsible for serving files from the storage directory at /v2/storage/.

• Error handling uses the anyhow crate for flexible error propagation, enabling integration with broader error management strategies in the system.

Diagram: Flow of Handling a Request in StorageLatestHandler

flowchart TD
A[Incoming HTTP Request] --> B[StorageLatestHandler::handle]
B --> C["get_latest_file(storage_dir)"]
C -->|Success| D[Redirect to /v2/storage/{file_name}]
C -->|Failure| E[Respond 404 with error]
D --> F[Client follows redirect]
E --> F

This flowchart illustrates the sequence from receiving a request through the handler, determining the latest file, and responding with either a redirect or an error.