use std::sync::Arc;
use tracing::trace;
use super::piece::Piece;
use super::piece_storage::{BitfieldMan, PieceStorage};
pub struct UnknownLengthPieceStorage {
piece: Option<Piece>,
bitfield: Option<BitfieldMan>,
total_length: u64,
piece_length: u64,
download_finished: bool,
disk_adaptor: Option<Arc<tokio::sync::Mutex<dyn crate::filesystem::disk_adaptor::DiskAdaptor>>>,
}
impl UnknownLengthPieceStorage {
pub fn new(piece_length: u64) -> Self {
trace!(piece_length, "UnknownLengthPieceStorage: created");
UnknownLengthPieceStorage {
piece: None,
bitfield: None,
total_length: 0,
piece_length,
download_finished: false,
disk_adaptor: None,
}
}
pub fn piece_length(&self) -> u64 {
self.piece_length
}
pub fn set_disk_adaptor(
&mut self,
adaptor: Arc<tokio::sync::Mutex<dyn crate::filesystem::disk_adaptor::DiskAdaptor>>,
) {
self.disk_adaptor = Some(adaptor);
}
pub fn get_disk_adaptor(
&self,
) -> Option<&Arc<tokio::sync::Mutex<dyn crate::filesystem::disk_adaptor::DiskAdaptor>>> {
self.disk_adaptor.as_ref()
}
}
impl PieceStorage for UnknownLengthPieceStorage {
fn has_missing_unused_piece(&self) -> bool {
!self.download_finished && self.piece.is_none()
}
fn get_missing_piece(
&mut self,
_min_split_size: u64,
_ignore_bitfield: &[u8],
_length: u64,
_cuid: u64,
) -> Option<Piece> {
if self.download_finished {
trace!("UnknownLengthPieceStorage: download already finished");
return None;
}
if self.piece.is_some() {
trace!("UnknownLengthPieceStorage: piece already checked out");
return None;
}
let piece = Piece::new(0, 0);
self.piece = Some(piece.clone());
trace!("UnknownLengthPieceStorage: checked out single piece");
Some(piece)
}
fn get_missing_piece_by_index(&mut self, index: usize, _cuid: u64) -> Option<Piece> {
if index != 0 {
trace!(index, "UnknownLengthPieceStorage: invalid piece index");
return None;
}
self.get_missing_piece(0, &[], 0, 0)
}
fn complete_piece(&mut self, piece: &Piece) -> bool {
if self.download_finished {
return true;
}
self.total_length = piece.length();
self.download_finished = true;
if self.total_length > 0 {
let mut bfman = BitfieldMan::new(self.piece_length, self.total_length);
bfman.mark_all_done();
self.bitfield = Some(bfman);
}
self.piece = None;
trace!(
total_length = self.total_length,
"UnknownLengthPieceStorage: download completed"
);
true
}
fn cancel_piece(&mut self, _piece: &mut Piece, _cuid: u64) {
if self.piece.is_some() {
trace!("UnknownLengthPieceStorage: piece cancelled");
self.piece = None;
}
}
fn has_piece(&self, index: usize) -> bool {
index == 0 && self.download_finished
}
fn is_piece_used(&self, index: usize) -> bool {
index == 0 && self.piece.is_some()
}
fn get_total_length(&self) -> u64 {
self.total_length
}
fn get_completed_length(&self) -> u64 {
if let Some(ref piece) = self.piece {
piece.length()
} else {
self.total_length
}
}
fn download_finished(&self) -> bool {
self.download_finished
}
fn all_download_finished(&self) -> bool {
self.download_finished
}
fn get_bitfield(&self) -> Vec<u8> {
match &self.bitfield {
Some(bfman) => bfman.bitfield().to_vec(),
None => Vec::new(),
}
}
fn set_bitfield(&mut self, _bitfield: &[u8]) {
}
fn mark_pieces_done(&mut self, _length: u64) {
}
fn is_end_game(&self) -> bool {
false
}
fn enter_end_game(&mut self) {
}
fn get_piece(&self, index: usize) -> Option<Piece> {
if index != 0 {
return None;
}
match &self.piece {
Some(p) => Some(p.clone()),
None => Some(Piece::new(0, 0)),
}
}
fn get_filtered_total_length(&self) -> u64 {
0
}
fn get_filtered_completed_length(&self) -> u64 {
self.get_completed_length()
}
fn get_bitfield_length(&self) -> usize {
match &self.bitfield {
Some(bfman) => bfman.bitfield_length(),
None => 0,
}
}
fn mark_all_pieces_done(&mut self) {
if let Some(ref piece) = self.piece {
self.total_length = piece.length();
}
self.piece = None;
if self.total_length > 0 {
let mut bfman = BitfieldMan::new(self.piece_length, self.total_length);
bfman.mark_all_done();
self.bitfield = Some(bfman);
}
self.download_finished = true;
}
fn mark_piece_missing(&mut self, _index: usize) {
}
fn mark_piece_verified(&mut self, _index: usize) {
}
fn mark_piece_failed(&mut self, _index: usize) {
}
fn read_data(&self, piece_index: usize) -> std::result::Result<Vec<u8>, String> {
if piece_index != 0 {
return Err(format!(
"Piece index {} out of range for unknown-length storage",
piece_index
));
}
if let Some(ref disk_adaptor) = self.disk_adaptor {
match disk_adaptor.try_lock() {
Ok(mut adaptor) => {
let rt = tokio::runtime::Handle::try_current();
match rt {
Ok(handle) => match handle.block_on(adaptor.read(0, self.total_length)) {
Ok(data) => Ok(data),
Err(e) => Err(format!("Disk read error: {}", e)),
},
Err(_) => {
Err("No tokio runtime available for synchronous read".to_string())
}
}
}
Err(_) => Err("Disk adaptor is busy (locked by another task)".to_string()),
}
} else {
Err("UnknownLengthPieceStorage: no disk adaptor connected".to_string())
}
}
fn set_end_game_piece_num(&mut self, _num: usize) {
}
fn get_piece_length(&self, index: usize) -> u32 {
if index != 0 {
return 0;
}
self.piece_length as u32
}
fn advertise_piece(&mut self, _cuid: u64, _index: usize) {
}
fn get_advertised_piece_indexes(
&self,
_my_cuid: u64,
last_have_index: u64,
) -> (Vec<usize>, u64) {
(Vec::new(), last_have_index)
}
fn remove_advertised_piece(&mut self, _expiry_ms: u64) {
}
fn add_in_flight_piece(&mut self, _piece: Piece) {
}
fn count_in_flight_piece(&self) -> usize {
0
}
fn get_in_flight_pieces(&self) -> Vec<Piece> {
Vec::new()
}
fn add_piece_stats_for_index(&mut self, _index: usize) {
}
fn add_piece_stats(&mut self, _bitfield: &[u8]) {
}
fn subtract_piece_stats(&mut self, _bitfield: &[u8]) {
}
fn update_piece_stats(&mut self, _new_bitfield: &[u8], _old_bitfield: &[u8]) {
}
fn get_next_used_index(&self, index: usize) -> usize {
if self.piece.is_some() || self.download_finished {
index + 1
} else {
1
}
}
fn on_download_incomplete(&mut self) {
}
fn is_selective_downloading_mode(&self) -> bool {
false
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_new_storage() {
let storage = UnknownLengthPieceStorage::new(1024 * 1024);
assert_eq!(storage.get_total_length(), 0);
assert!(!storage.download_finished());
assert!(!storage.all_download_finished());
assert!(storage.has_missing_unused_piece());
}
#[test]
fn test_checkout_single_piece() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let piece = storage.get_missing_piece(0, &[], 0, 1);
assert!(piece.is_some());
let piece = piece.unwrap();
assert_eq!(piece.index(), 0);
assert!(storage.is_piece_used(0));
assert!(!storage.has_missing_unused_piece());
}
#[test]
fn test_checkout_only_once() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let p1 = storage.get_missing_piece(0, &[], 0, 1);
assert!(p1.is_some());
let p2 = storage.get_missing_piece(0, &[], 0, 2);
assert!(p2.is_none());
}
#[test]
fn test_cancel_piece_allows_recheckout() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let mut piece = storage.get_missing_piece(0, &[], 0, 1).unwrap();
storage.cancel_piece(&mut piece, 1);
assert!(!storage.is_piece_used(0));
assert!(storage.has_missing_unused_piece());
let p2 = storage.get_missing_piece(0, &[], 0, 2);
assert!(p2.is_some());
}
#[test]
fn test_complete_piece() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let mut piece = storage.get_missing_piece(0, &[], 0, 1).unwrap();
piece.set_length(50000);
piece.reconfigure(50000);
piece.set_all_blocks();
let result = storage.complete_piece(&piece);
assert!(result);
assert!(storage.download_finished());
assert_eq!(storage.get_total_length(), 50000);
assert_eq!(storage.get_completed_length(), 50000);
}
#[test]
fn test_no_checkout_after_completion() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let mut piece = storage.get_missing_piece(0, &[], 0, 1).unwrap();
piece.set_length(1000);
piece.reconfigure(1000);
piece.set_all_blocks();
storage.complete_piece(&piece);
let result = storage.get_missing_piece(0, &[], 0, 2);
assert!(result.is_none());
assert!(!storage.has_missing_unused_piece());
}
#[test]
fn test_has_piece() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
assert!(!storage.has_piece(0));
let mut piece = storage.get_missing_piece(0, &[], 0, 1).unwrap();
piece.set_length(500);
piece.reconfigure(500);
piece.set_all_blocks();
storage.complete_piece(&piece);
assert!(storage.has_piece(0));
assert!(!storage.has_piece(1));
}
#[test]
fn test_get_bitfield_before_completion() {
let storage = UnknownLengthPieceStorage::new(1024 * 1024);
assert!(storage.get_bitfield().is_empty());
}
#[test]
fn test_get_bitfield_after_completion() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let mut piece = storage.get_missing_piece(0, &[], 0, 1).unwrap();
piece.set_length(2 * 1024 * 1024);
piece.reconfigure(2 * 1024 * 1024);
piece.set_all_blocks();
storage.complete_piece(&piece);
let bf = storage.get_bitfield();
assert!(!bf.is_empty());
assert_eq!(
bf[0], 0b11000000,
"First byte should have bits 0,1 set for 2 pieces"
);
}
#[test]
fn test_get_missing_piece_by_index() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let piece = storage.get_missing_piece_by_index(0, 1);
assert!(piece.is_some());
let mut storage2 = UnknownLengthPieceStorage::new(1024 * 1024);
let result = storage2.get_missing_piece_by_index(1, 1);
assert!(result.is_none());
}
#[test]
fn test_set_bitfield_noop() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
storage.set_bitfield(&[0xFF]);
assert!(storage.get_bitfield().is_empty());
}
#[test]
fn test_mark_pieces_done_noop() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
storage.mark_pieces_done(1000);
assert_eq!(storage.get_total_length(), 0);
}
#[test]
fn test_end_game_not_supported() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
assert!(!storage.is_end_game());
storage.enter_end_game();
assert!(!storage.is_end_game());
}
#[test]
fn test_completed_length_before_checkout() {
let storage = UnknownLengthPieceStorage::new(1024 * 1024);
assert_eq!(storage.get_completed_length(), 0);
}
#[test]
fn test_complete_piece_twice() {
let mut storage = UnknownLengthPieceStorage::new(1024 * 1024);
let mut piece = storage.get_missing_piece(0, &[], 0, 1).unwrap();
piece.set_length(1000);
piece.reconfigure(1000);
piece.set_all_blocks();
storage.complete_piece(&piece);
let result = storage.complete_piece(&piece);
assert!(result);
assert_eq!(storage.get_total_length(), 1000);
}
}