spill 0.5.2

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

//! Peer closures are recoverable; local failures terminate the torrent.
use std::io;

#[derive(Debug, thiserror::Error)]
pub(in crate::engine) enum PeerError {
    #[error("{0}")]
    Remote(#[source] io::Error),
    #[error("{0}")]
    Local(#[source] io::Error),
}

pub(in crate::engine) fn is_local(error: &io::Error) -> bool {
    !matches!(
        error.get_ref().and_then(|e| e.downcast_ref::<PeerError>()),
        Some(PeerError::Remote(_))
    )
}

pub(in crate::engine) mod peer {
    use super::*;
    use tokio::task::JoinError;

    fn remote(error: io::Error) -> io::Error {
        io::Error::new(error.kind(), PeerError::Remote(error))
    }
    fn local(error: io::Error) -> io::Error {
        io::Error::new(error.kind(), PeerError::Local(error))
    }
    pub(in crate::engine) fn handshake_expired() -> io::Error {
        remote(io::Error::new(
            io::ErrorKind::TimedOut,
            "peer handshake deadline",
        ))
    }
    pub(in crate::engine) fn io_deadline() -> io::Error {
        remote(io::Error::new(io::ErrorKind::TimedOut, "peer I/O deadline"))
    }
    pub(in crate::engine) fn invalid(message: &'static str) -> io::Error {
        local(io::Error::new(io::ErrorKind::InvalidInput, message))
    }
    pub(in crate::engine) fn busy(message: &'static str) -> io::Error {
        remote(io::Error::new(io::ErrorKind::WouldBlock, message))
    }
    pub(in crate::engine) fn task_failed(error: JoinError) -> io::Error {
        local(io::Error::other(error))
    }
    pub(in crate::engine) fn event_receiver_closed() -> io::Error {
        local(io::Error::new(
            io::ErrorKind::BrokenPipe,
            "peer event receiver closed",
        ))
    }
    pub(in crate::engine) fn socket_failure(error: io::Error) -> io::Error {
        match error.kind() {
            io::ErrorKind::InvalidInput | io::ErrorKind::Other | io::ErrorKind::OutOfMemory => {
                local(error)
            }
            _ => remote(error),
        }
    }
    pub(in crate::engine) fn protocol(message: &'static str) -> io::Error {
        remote(io::Error::new(io::ErrorKind::InvalidData, message))
    }
    pub(in crate::engine) fn invalid_data(
        error: impl std::error::Error + Send + Sync + 'static,
    ) -> io::Error {
        remote(io::Error::new(io::ErrorKind::InvalidData, error))
    }
    pub(in crate::engine) fn invalid_message(
        error: impl std::error::Error + Send + Sync + 'static,
    ) -> io::Error {
        local(io::Error::new(io::ErrorKind::InvalidData, error))
    }
}