spill 0.5.1

Modern torrent client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use super::*;

impl Torrent {
    pub(super) fn maybe_hash(&mut self) -> io::Result<()> {
        let indices: Vec<_> = self
            .picker
            .pieces()
            .filter(|piece| {
                !piece.hashing
                    && !self.writing.contains_key(&piece.index)
                    && self.picker.ready_to_hash(piece.index, self.meta.layout())
            })
            .map(|p| p.index)
            .collect();
        for index in indices {
            if self.write_capacity == 0 {
                break;
            }
            self.write_capacity -= 1;
            self.actions.push(Action::Hash { piece: index });
            self.picker.hash_started(index);
        }
        Ok(())
    }
    pub(super) fn restart_piece(&mut self, index: u32, corrupt: bool) -> io::Result<Event> {
        self.mark_all_dirty();
        self.actions.push(Action::Discard { piece: index });
        let culprit = corrupt.then(|| self.picker.culprit(index)).flatten();
        if let Some(source) = culprit
            && let Some(&position) = self.remote_slots.get(&source)
        {
            if let Some(id) = self.remotes[position]
                .peer_id
                .filter(|_| !self.remotes[position].web_seed)
            {
                self.banned
                    .retain(|(other, _, until)| *other != id && *until > self.now);
                if self.banned.len() >= self.limits.peers.saturating_mul(4).max(1) {
                    self.banned.pop_front();
                }
                self.banned.push_back((
                    id,
                    self.remotes[position]
                        .extensions
                        .pex
                        .endpoint
                        .map(|a| a.ip().to_canonical()),
                    self.now + Duration::from_secs(1800),
                ));
            }
            self.retire_peer(
                position,
                invalid_data_text("single-source piece hash mismatch"),
            )?;
        }
        if let Some(position) = self.remotes.iter().position(|p| {
            eligible(p, index)
                && !self.picker.used_peer(index, p.connection)
                && !p.asked.iter().any(|request| request.index == index)
        }) {
            self.peer_cursor = position;
        }
        for peer in &mut self.remotes {
            peer.asked.retain(|request| request.index != index);
        }
        self.picker.on_hash_result(index, false, self.now)
    }
    pub(super) fn on_hash(&mut self, index: u32, verified: bool) -> io::Result<Event> {
        self.mark_all_dirty();
        if self.picker.piece(index).is_none_or(|p| !p.hashing) {
            return Err(io::Error::other("unexpected hash result"));
        }
        if !verified {
            return self.restart_piece(index, true);
        }
        self.mark_verified(index);
        self.useful_at = self.now;
        self.picker.on_hash_result(index, true, self.now)
    }
    pub(super) fn mark_verified(&mut self, index: u32) {
        if has(&self.verified, index) {
            return;
        }
        let range = self.meta.layout().piece_range(index).expect("piece");
        self.verified_bytes += range.end - range.start;
        self.wanted_verified_bytes += self
            .selection
            .as_ref()
            .map_or(range.end - range.start, |s| {
                s.piece_wanted_bytes(self.meta.layout(), index)
            });
        if !has(&self.excluded, index) {
            self.wanted_remaining -= 1;
        }
        set(&mut self.excluded, index);
        set(&mut self.verified, index);
        self.picker.unrequested(index, false);
        self.verified_count += 1;
        for peer in &mut self.remotes {
            if peer.first_needed == Some(index) {
                peer.first_needed = first_difference(&peer.pieces, &self.excluded, index + 1);
            }
            peer.pending_have = Some(peer.pending_have.map_or(index, |old| old.min(index)));
        }
    }
}