torrust-tracker 3.0.0

A feature rich BitTorrent tracker.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Aquatic responses are not serializable. These are the serializable wrappers.
use std::net::{Ipv4Addr, Ipv6Addr};

use aquatic_udp_protocol::Response::{self};
use aquatic_udp_protocol::{AnnounceResponse, ConnectResponse, ErrorResponse, Ipv4AddrBytes, Ipv6AddrBytes, ScrapeResponse};
use serde::Serialize;

#[derive(Serialize)]
pub enum SerializableResponse {
    Connect(ConnectSerializableResponse),
    AnnounceIpv4(AnnounceSerializableResponse),
    AnnounceIpv6(AnnounceSerializableResponse),
    Scrape(ScrapeSerializableResponse),
    Error(ErrorSerializableResponse),
}

impl From<Response> for SerializableResponse {
    fn from(response: Response) -> Self {
        match response {
            Response::Connect(response) => SerializableResponse::Connect(ConnectSerializableResponse::from(response)),
            Response::AnnounceIpv4(response) => SerializableResponse::AnnounceIpv4(AnnounceSerializableResponse::from(response)),
            Response::AnnounceIpv6(response) => SerializableResponse::AnnounceIpv6(AnnounceSerializableResponse::from(response)),
            Response::Scrape(response) => SerializableResponse::Scrape(ScrapeSerializableResponse::from(response)),
            Response::Error(response) => SerializableResponse::Error(ErrorSerializableResponse::from(response)),
        }
    }
}

#[derive(Serialize)]
pub struct ConnectSerializableResponse {
    transaction_id: i32,
    connection_id: i64,
}

impl From<ConnectResponse> for ConnectSerializableResponse {
    fn from(connect: ConnectResponse) -> Self {
        Self {
            transaction_id: connect.transaction_id.0.into(),
            connection_id: connect.connection_id.0.into(),
        }
    }
}

#[derive(Serialize)]
pub struct AnnounceSerializableResponse {
    transaction_id: i32,
    announce_interval: i32,
    leechers: i32,
    seeders: i32,
    peers: Vec<String>,
}

impl From<AnnounceResponse<Ipv4AddrBytes>> for AnnounceSerializableResponse {
    fn from(announce: AnnounceResponse<Ipv4AddrBytes>) -> Self {
        Self {
            transaction_id: announce.fixed.transaction_id.0.into(),
            announce_interval: announce.fixed.announce_interval.0.into(),
            leechers: announce.fixed.leechers.0.into(),
            seeders: announce.fixed.seeders.0.into(),
            peers: announce
                .peers
                .iter()
                .map(|peer| format!("{}:{}", Ipv4Addr::from(peer.ip_address), peer.port.0))
                .collect::<Vec<_>>(),
        }
    }
}

impl From<AnnounceResponse<Ipv6AddrBytes>> for AnnounceSerializableResponse {
    fn from(announce: AnnounceResponse<Ipv6AddrBytes>) -> Self {
        Self {
            transaction_id: announce.fixed.transaction_id.0.into(),
            announce_interval: announce.fixed.announce_interval.0.into(),
            leechers: announce.fixed.leechers.0.into(),
            seeders: announce.fixed.seeders.0.into(),
            peers: announce
                .peers
                .iter()
                .map(|peer| format!("{}:{}", Ipv6Addr::from(peer.ip_address), peer.port.0))
                .collect::<Vec<_>>(),
        }
    }
}

#[derive(Serialize)]
pub struct ScrapeSerializableResponse {
    transaction_id: i32,
    torrent_stats: Vec<TorrentStats>,
}

impl From<ScrapeResponse> for ScrapeSerializableResponse {
    fn from(scrape: ScrapeResponse) -> Self {
        Self {
            transaction_id: scrape.transaction_id.0.into(),
            torrent_stats: scrape
                .torrent_stats
                .iter()
                .map(|torrent_scrape_statistics| TorrentStats {
                    seeders: torrent_scrape_statistics.seeders.0.into(),
                    completed: torrent_scrape_statistics.completed.0.into(),
                    leechers: torrent_scrape_statistics.leechers.0.into(),
                })
                .collect::<Vec<_>>(),
        }
    }
}

#[derive(Serialize)]
pub struct ErrorSerializableResponse {
    transaction_id: i32,
    message: String,
}

impl From<ErrorResponse> for ErrorSerializableResponse {
    fn from(error: ErrorResponse) -> Self {
        Self {
            transaction_id: error.transaction_id.0.into(),
            message: error.message.to_string(),
        }
    }
}

#[derive(Serialize)]
struct TorrentStats {
    seeders: i32,
    completed: i32,
    leechers: i32,
}