Struct DownloadManager 

pub struct DownloadManager {
    AppState: Arc<ApplicationState>,
    ActiveDownloads: Arc<RwLock<HashMap<String, DownloadStatus>>>,
    DownloadQueue: Arc<RwLock<VecDeque<QueuedDownload>>>,
    CacheDirectory: PathBuf,
    client: Client,
    ChecksumVerifier: Arc<ChecksumVerifier>,
    BandwidthLimiter: Arc<Semaphore>,
    TokenBucket: Arc<RwLock<TokenBucket>>,
    ConcurrentLimiter: Arc<Semaphore>,
    statistics: Arc<RwLock<DownloadStatistics>>,
}

Download manager implementation with full resilience and capabilities

Fields

AppState: Arc<ApplicationState>

Application state reference

ActiveDownloads: Arc<RwLock<HashMap<String, DownloadStatus>>>

Active downloads tracking

DownloadQueue: Arc<RwLock<VecDeque<QueuedDownload>>>

Download queue with priority ordering

CacheDirectory: PathBuf

Download cache directory

client: Client

HTTP client with connection pooling

ChecksumVerifier: Arc<ChecksumVerifier>

Checksum verifier helper

BandwidthLimiter: Arc<Semaphore>

Bandwidth limiter for global control

TokenBucket: Arc<RwLock<TokenBucket>>

Token bucket for rate limiting

ConcurrentLimiter: Arc<Semaphore>

Concurrent download limiter

statistics: Arc<RwLock<DownloadStatistics>>

Download statistics

Implementations

impl DownloadManager

pub async fn new(AppState: Arc<ApplicationState>) -> Result<Self>

Create a new download manager with comprehensive initialization

pub async fn DownloadFile( &self, url: String, DestinationPath: String, checksum: String, ) -> Result<DownloadResult>

Download a file with comprehensive validation and resilience

pub async fn DownloadFileWithConfig( &self, config: DownloadConfig, ) -> Result<DownloadResult>

Download a file with detailed configuration

fn ValidateAndSanitizeUrl(url: &str) -> Result<String>

Validate and sanitize URL to prevent injection attacks

async fn ValidateDiskSpace( &self, url: &str, destination: &Path, RequiredBytes: u64, ) -> Result<()>

Validate available disk space before download

fn GetDiskStatvfs(&self, path: &Path) -> Result<(u64, u64)>

Get disk statistics using statvfs (Unix)

fn FindMountPoint(&self, path: &Path) -> Result<PathBuf>

Find mount point for a given path

async fn DownloadWithRetry( &self, DownloadId: &str, url: &str, destination: &PathBuf, config: &DownloadConfig, ) -> Result<DownloadResult>

Download with retry logic and circuit breaker

async fn PerformDownload( &self, DownloadId: &str, url: &str, destination: &PathBuf, config: &DownloadConfig, ) -> Result<DownloadResult>

Perform the actual download with streaming and partial resume support

pub async fn VerifyChecksum( &self, FilePath: &PathBuf, ExpectedChecksum: &str, ) -> Result<()>

Verify file checksum using ChecksumVerifier

pub async fn CalculateChecksum(&self, FilePath: &PathBuf) -> Result<String>

Calculate file checksum using ChecksumVerifier

async fn RegisterDownload( &self, DownloadId: &str, url: &str, destination: &PathBuf, ExpectedChecksum: Option<String>, ) -> Result<()>

Register a new download in the tracking system

async fn UpdateDownloadStatus( &self, DownloadId: &str, status: DownloadState, progress: Option<f32>, error: Option<String>, ) -> Result<()>

Update download status

async fn UpdateDownloadRate(&self, DownloadId: &str, rate: u64)

Update download rate tracking

async fn UpdateActualChecksum(&self, DownloadId: &str, checksum: &str)

Update actual checksum after calculation

async fn CalculateDownloadRate( &self, DownloadId: &str, CurrentBytes: u64, ) -> u64

Calculate download rate based on progress

async fn UpdateStatistics(&self, success: bool, bytes: u64, duration: Duration)

Update download statistics

pub async fn GetDownloadStatus( &self, DownloadId: &str, ) -> Option<DownloadStatus>

Get download status

pub async fn GetAllDownloads(&self) -> Vec<DownloadStatus>

Get all active downloads

pub async fn CancelDownload(&self, DownloadId: &str) -> Result<()>

Cancel a download with proper cleanup

pub async fn PauseDownload(&self, DownloadId: &str) -> Result<()>

Pause a download (supports resume)

pub async fn ResumeDownload(&self, DownloadId: &str) -> Result<()>

Resume a paused download

pub async fn GetActiveDownloadCount(&self) -> usize

Get active download count

pub async fn GetStatistics(&self) -> DownloadStatistics

Get download statistics

pub async fn QueueDownload( &self, url: String, destination: String, checksum: String, priority: DownloadPriority, ) -> Result<String>

Queue a download with priority

pub async fn ProcessQueue(&self) -> Result<Option<String>>

Process next download from queue

pub async fn StartBackgroundTasks(&self) -> Result<JoinHandle<()>>

Start background tasks for cleanup and queue processing

async fn BackgroundTaskLoop(&self)

Background task loop for cleanup and queue processing

async fn CleanupCompletedDownloads(&self)

Clean up completed downloads from active tracking

async fn CleanupCache(&self) -> Result<()>

Clean up old cache files with safety checks

pub async fn StopBackgroundTasks(&self)

Stop background tasks and clean up resources

pub async fn SetBandwidthLimit(&mut self, mb_per_sec: usize)

Set global bandwidth limit (in MB/s)

Updates the token bucket refill rate to enforce the bandwidth limit. The token bucket allows short bursts up to 5x the configured rate.

Arguments

• mb_per_sec - Maximum download speed in megabytes per second (1-1000)

Example

downloader.SetBandwidthLimit(10).await; // Limit to 10 MB/s

pub async fn SetMaxConcurrentDownloads(&mut self, max: usize)

Set maximum concurrent downloads TODO: Implement per-host concurrent download limits TODO: Add adaptive concurrency based on network conditions

impl DownloadManager

Extension download and validation for Cocoon

Cocoon (Extension Host) downloads VSIX files from marketplace APIs:

1. Request VSIX download URL from marketplace
2. Validate extension manifest metadata
3. Download with progress callbacks for UI updates
4. Verify SHA-256 checksum of signed .vsix package
5. Atomic commit to extension installation directory
6. Extract contents and validate before installation

Example Cocoon workflow:

let download_config = DownloadConfig {
	url:marketplace_vsix_url,
	destination:extension_path,
	checksum:expected_sha256,
	priority:DownloadPriority::High,
	..Default::default()
};
let result = downloader.DownloadFileWithConfig(download_config).await?;
downloader.VerifyChecksum(&PathBuf::from(result.path), &expected_sha256).await?;

Package downloads for Mountain (Tauri bundling):

1. Build system initiates dependency downloads
2. DownloadManager validates package signatures
3. Parallel chunk downloads for large packages (>50MB)
4. Bandwidth throttling to prevent network saturation
5. Atomic staging with final commit to build cache

VSIX download and validation:

• Supports marketplace API authentication tokens
• Validates extension manifest before download
• Verifies package signature after download
• Extracts and validates contents before installation

pub async fn DownloadFileWithChunks( &self, url: String, destination: String, checksum: String, chunk_size_mb: usize, ) -> Result<DownloadResult>

Download a large file using parallel chunked downloads

This feature is in progress and will be enhanced with:

• Dynamic chunk size optimization based on bandwidth
• Adaptive chunk count based on file size
• Reassembly with integrity verification TODO: Add adaptive chunk size based on network conditions TODO: Implement parallel download queue management with priority TODO: Add chunk verification and re-download of failed chunks

async fn GetRemoteFileSize(&self, url: &str) -> Result<u64>

Get remote file size using HEAD request

async fn DownloadChunk( &self, url: &str, chunk: &ChunkInfo, chunk_index: usize, ) -> Result<()>

Download a single chunk using HTTP Range request

async fn ReassembleChunks( &self, chunks: &[ChunkInfo], destination: &Path, ) -> Result<()>

Reassemble downloaded chunks into final file

Trait Implementations

impl Clone for DownloadManager

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.