aria2-protocol 0.3.10

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
//! BEP 9 metadata piece collection and assembly.

use std::fmt;

/// Collect BEP 9 metadata pieces and assemble them in wire order.
pub struct MetadataCollector {
    total_size: u64,
    collected: Vec<Option<Vec<u8>>>,
    piece_size: u32,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MetadataCollectorError {
    ZeroPieceSize,
}

impl fmt::Display for MetadataCollectorError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::ZeroPieceSize => f.write_str("metadata piece size must be non-zero"),
        }
    }
}

impl std::error::Error for MetadataCollectorError {}

impl MetadataCollector {
    pub fn new(total_size: u64, piece_size: u32) -> Result<Self, MetadataCollectorError> {
        if piece_size == 0 {
            return Err(MetadataCollectorError::ZeroPieceSize);
        }

        let num_pieces = total_size.div_ceil(u64::from(piece_size)) as usize;
        Ok(Self {
            total_size,
            collected: vec![None; num_pieces],
            piece_size,
        })
    }

    pub fn add_piece(&mut self, piece_idx: u32, data: &[u8]) -> bool {
        let idx = piece_idx as usize;
        if idx >= self.collected.len() || self.collected[idx].is_some() {
            return false;
        }
        let offset = u64::from(piece_idx) * u64::from(self.piece_size);
        let expected_len = self
            .total_size
            .saturating_sub(offset)
            .min(u64::from(self.piece_size));
        if data.len() as u64 != expected_len {
            return false;
        }
        self.collected[idx] = Some(data.to_vec());
        true
    }

    pub fn is_complete(&self) -> bool {
        self.collected.iter().all(Option::is_some)
    }

    pub fn into_bytes(self) -> Option<Vec<u8>> {
        if self.collected.iter().any(Option::is_none) {
            return None;
        }
        let mut result = Vec::with_capacity(self.total_size as usize);
        for piece in self.collected {
            result.extend(piece.expect("complete metadata has every piece"));
        }
        Some(result)
    }

    pub fn progress(&self) -> f64 {
        let done = self
            .collected
            .iter()
            .filter(|piece| piece.is_some())
            .count();
        if self.collected.is_empty() {
            0.0
        } else {
            done as f64 / self.collected.len() as f64
        }
    }
}

#[cfg(test)]
mod tests {
    use super::{MetadataCollector, MetadataCollectorError};

    #[test]
    fn rejects_wrong_piece_lengths() {
        let mut collector = MetadataCollector::new(3, 2).unwrap();
        assert!(!collector.add_piece(0, b"x"));
        assert!(collector.add_piece(0, b"ab"));
        assert!(collector.add_piece(1, b"c"));
        assert_eq!(collector.into_bytes(), Some(b"abc".to_vec()));
    }

    #[test]
    fn reports_empty_collection_as_complete() {
        let collector = MetadataCollector::new(0, 16 * 1024).unwrap();
        assert!(collector.is_complete());
        assert_eq!(collector.progress(), 0.0);
        assert_eq!(collector.into_bytes(), Some(Vec::new()));
    }

    #[test]
    fn rejects_zero_piece_size() {
        assert!(matches!(
            MetadataCollector::new(1, 0),
            Err(MetadataCollectorError::ZeroPieceSize)
        ));
    }
}