aria2-core 0.3.13

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;

use tokio::sync::mpsc;

use crate::engine::concurrent_segment_manager::{ConcurrentSegmentManager, SegmentStatus};
use crate::engine::http::adaptive_concurrency::HttpAdaptiveConcurrency;
use crate::engine::http::request_executor::{HttpSegmentRequest, HttpSegmentRequestExecutor};
use crate::engine::http::segment_downloader::{
    SegmentProgress, SegmentProgressTracker, WriteChunk,
};
use crate::engine::work_scheduler::{WorkLease, WorkScheduler};
use crate::error::Result;
use crate::request::request_group::ActiveConnectionGuard;

use super::ActiveSegment;

pub(super) struct Admission<'a> {
    pub(super) uri: &'a str,
    pub(super) total_length: u64,
    pub(super) split: usize,
    pub(super) authority_key: &'a str,
    pub(super) cookie_header: &'a Option<String>,
    pub(super) range_size_limit: u64,
    pub(super) executor: &'a mut HttpSegmentRequestExecutor,
    pub(super) adaptive: &'a mut HttpAdaptiveConcurrency,
    pub(super) manager: &'a mut ConcurrentSegmentManager,
    pub(super) progress_tracker: &'a Arc<SegmentProgressTracker>,
    pub(super) segment_progress: &'a mut HashMap<u32, Arc<SegmentProgress>>,
    pub(super) active_segments: &'a mut HashMap<u32, ActiveSegment>,
    pub(super) active_work: &'a mut HashMap<u32, WorkLease<u32>>,
    pub(super) work_queue: &'a mut WorkScheduler<u32>,
    pub(super) write_tx: &'a mpsc::Sender<WriteChunk>,
    pub(super) connection_guard: &'a ActiveConnectionGuard,
}

pub(super) fn admit_pending_ranges(admission: Admission<'_>) -> Result<()> {
    super::executor::update_capacity(
        admission.executor,
        admission.adaptive,
        admission.authority_key,
        admission.split,
        admission.manager.is_complete(),
    );

    while admission.adaptive.can_start(
        admission.executor.in_flight_for(admission.authority_key),
        admission.executor.is_http2(admission.authority_key),
    ) {
        let Some(lease) = admission
            .work_queue
            .admit_one(admission.split, Instant::now())
        else {
            break;
        };
        let segment_index = *lease.payload();
        match admission.manager.next_pending_range_for_segment(
            0,
            segment_index,
            admission.range_size_limit,
        ) {
            Some((_, offset, length)) => {
                let progress = admission.progress_tracker.new_segment();
                admission
                    .segment_progress
                    .insert(segment_index, Arc::clone(&progress));
                let started_at = Instant::now();
                let submitted = admission.executor.try_submit(HttpSegmentRequest {
                    segment_index,
                    authority_key: admission.authority_key.to_owned(),
                    url: admission.uri.to_owned(),
                    offset,
                    length,
                    range_size_limit: admission.range_size_limit,
                    cookie_header: admission.cookie_header.clone(),
                    progress,
                    write_tx: admission.write_tx.clone(),
                    expected_entity_length: admission.total_length,
                });
                let Some(task_id) = submitted else {
                    admission.segment_progress.remove(&segment_index);
                    admission.manager.requeue_segment(segment_index);
                    admission
                        .work_queue
                        .requeue_unstarted(lease)
                        .map_err(|error| {
                            super::work_scheduler_error("requeue an unstarted range", error)
                        })?;
                    break;
                };
                admission.active_segments.insert(
                    segment_index,
                    ActiveSegment {
                        offset,
                        length,
                        started_at,
                        task_id,
                    },
                );
                admission
                    .adaptive
                    .record_request_start(admission.executor.is_http2(admission.authority_key));
                admission.active_work.insert(segment_index, lease);
                super::executor::update_connection_snapshot(
                    admission.executor,
                    admission.connection_guard,
                );
                tracing::debug!(
                    segment_index,
                    task_id,
                    offset,
                    length,
                    "Submitted segment to HTTP connection pool"
                );
            }
            None => match admission.manager.segment_status(segment_index as usize) {
                Some(SegmentStatus::Done | SegmentStatus::Failed) => {
                    admission.work_queue.complete(lease).map_err(|error| {
                        super::work_scheduler_error("complete a terminal range", error)
                    })?;
                }
                _ => {
                    admission
                        .work_queue
                        .requeue_unstarted(lease)
                        .map_err(|error| {
                            super::work_scheduler_error("requeue a blocked range", error)
                        })?;
                    break;
                }
            },
        }
    }

    Ok(())
}