mediafire_rs

You can use the MediafireDownloader from the md_downloader crate to programmatically download files from Mediafire. The workflow involves initializing a downloader with a retry count, configuring proxies and download order, and then generating download jobs with progress tracking.

Key steps:

1. Initialize MediafireDownloader::new(tries).
2. Configure behavior using .reverse_downloads(bool) and .set_proxies(proxies, use_proxies_for_downloads).
3. Call .get_download_jobs_with_progress(urls, output_path, progress_callback) to prepare the jobs.
4. The progress callback receives the current filename being processed, allowing you to update UI elements like progress bars.

use md_downloader::MediafireDownloader;

// Initialize downloader with 3 retries
let downloader = MediafireDownloader::new(3)?
    .reverse_downloads(false)
    .set_proxies(proxies, true);

// Get jobs with a progress callback
let jobs = downloader
    .get_download_jobs_with_progress(&urls, "./downloads", |filename| {
        println!("Currently downloading: {}", filename);
    })
    .await?;

The download_file function manages the lifecycle of a single file download, including progress bar updates and automatic retries upon failure. It uses indicatif for visual feedback and integrates with md_downloader types.

Parameters:

• download_job: A reference to a DownloadJob containing the file metadata and download logic.
• tries: A u64 representing the number of retry attempts allowed.
• multi: An Arc<MultiProgress> used to manage multiple concurrent progress bars.
• styles: An Arc<ProgressStyles> defining the visual appearance of the progress bars for different states (normal, download, error).

Behavior:

• It creates a new ProgressBar within the provided MultiProgress container.
• If a download attempt fails, it waits for 2 seconds (RETRY_SECS) before retrying, provided tries > 0.
• It updates the progress bar prefix and style based on the current state (e.g., "Getting link...", "Checking hash...", "Retrying...").
• If all retries are exhausted, it returns the last encountered DownloadError and marks the progress bar with a ❌ icon.

use std::sync::Arc;
use indicatif::MultiProgress;
// Assuming these types are available from the crate
// use mediafire_rs::{DownloadJob, ProgressStyles, DownloadError};

// Example invocation pattern:
// download_file(&job, 3, multi_progress, styles).await?;

The Config struct defines the operational parameters for the application. You can instantiate it using Config::new(). This struct controls how URLs are processed, where files are saved, concurrency limits, retry logic, and proxy settings.

use std::path::PathBuf;

let config = Config::new(
    vec!["https://www.mediafire.com/file/example".to_string()], // urls
    None,                                                      // input_file
    PathBuf::from("./downloads"),                            // output_path
    5,                                                         // max (concurrency/limit)
    3,                                                         // tries (retries)
    false,                                                     // reverse_order
    None,                                                      // proxy_file
    false,                                                     // proxy_downloads
);