The project is being refactored and will not dependent on the asynchronous runtime

Features

• Multithreaded download
• Breakpoint resume
• Download speed limit
• Download speed tracking
• Modify at download time
  • max parallel connection count
  • max download speed
  • chunk size

Required minimum dependency

toml http-downloader = { version = "0.1" } url = { version = "2" } tokio = { version = "1", features = ["rt", "macros"] }

A simple http downloader

terminal ui：https://github.com/ycysdf/http-downloader-tui

cargo futures

Some features are not enabled by default

```toml [features]

tokio tracing

default = ["tracing"]

async-graphql input or output objects

async-graphql = ["dep:async-graphql"]

all extensions

all-extensions = ["status-tracker", "speed-limiter", "speed-tracker", "breakpoint-resume", "tracing", "bson-file-archiver"]

download status tracking

status-tracker = ["tracing"]

download speed tracing

speed-tracker = ["tracing"]

download speed limit

speed-limiter = ["tracing"]

download breakpoint resume

breakpoint-resume = ["tracing"]

download breakpoint resume，bson file storage

bson-file-archiver = ["breakpoint-resume", "tracing", "serde", "bson", "url/serde"] ```

Example

```rust

use std::num::{NonZeroU8, NonZeroUsize}; use std::path::PathBuf; use std::time::Duration;

use anyhow::Result; use tracing::info; use url::Url;

use httpdownloader::{ breakpointresume::DownloadBreakpointResumeExtension, HttpDownloaderBuilder, speedlimiter::DownloadSpeedLimiterExtension, speedtracker::DownloadSpeedTrackerExtension, statustracker::DownloadStatusTrackerExtension, }; use httpdownloader::bsonfilearchiver::{ArchiveFilePath, BsonFileArchiverBuilder};

[tokio::main]

async fn main() -> Result<()> { { tracing_subscriber::fmt::init(); }

let savedir = PathBuf::from("C:/download"); let testurl = Url::parse("http://mirror.hk.leaseweb.net/speedtest/1000mb.bin")?; let (downloader, (statusstate, speedstate, speedlimiter, ..)) = HttpDownloaderBuilder::new(testurl, savedir) .chunksize(NonZeroUsize::new(1024 * 1024 * 10).unwrap()) // 块大小 .downloadconnectioncount(NonZeroU8::new(3).unwrap()) // 下载连接数 .build(( // 下载状态追踪扩展 // by cargo feature "status-tracker" enable DownloadStatusTrackerExtension { log: true }, // 下载速度追踪扩展 // by cargo feature "speed-tracker" enable DownloadSpeedTrackerExtension { log: true }, // 下载速度限制扩展， // by cargo feature "speed-limiter" enable DownloadSpeedLimiterExtension::new(None), // 断点续传扩展， // by cargo feature "breakpoint-resume" enable DownloadBreakpointResumeExtension { // BsonFileArchiver by cargo feature "bson-file-archiver" enable downloadarchiverbuilder: BsonFileArchiverBuilder::new(ArchiveFilePath::Suffix("bson".tostring())) } )); info!("Start download，开始下载"); let finishedfuture = downloader.start().await?;

let status = statusstate.status(); // get download status， 获取状态 let statusreceiver = statusstate.statusreceiver; //status watcher，状态监听器 let bytepersecond = speedstate.downloadspeed(); // get download speed，Byte per second，获取速度，字节每秒 let _speedreceiver = speed_state.receiver; // get download speed watcher，速度监听器

// downloader.cancel() // 取消下载

// 打印下载进度 // Print download Progress tokio::spawn({ let mut downloadedlenreceiver = downloader.downloadedlenreceiver().clone(); async move { let totallen = downloader.totalsize().await; if let Some(totallen) = totallen { info!("Total size: {:.2} Mb",totallen.get() as f64 / 1024f64/ 1024f64); } while downloadedlenreceiver.changed().await.isok() { let progress = downloaded_len_receiver.borrow(); if let Some(total_len) = total_len { info!("Download Progress: {} %，{}/{}",progress100/totallen,progress,totallen); }

    tokio::time::sleep(Duration::from_millis(1000)).await;
  }
}

});

// 下载速度限制 // Download speed limit tokio::spawn(async move { tokio::time::sleep(Duration::fromsecs(2)).await; info!("Start speed limit，开始限速"); speedlimiter.changespeed(Some(1024 * 1024 * 2)).await; tokio::time::sleep(Duration::fromsecs(4)).await; info!("Remove the download speed limit，解除速度限制"); speedlimiter.changespeed(None).await; });

info!("Wait for download to end，等待下载结束"); let dec = finished_future.await?; info!("Downloading end cause: {:?}", dec); Ok(()) } ```