redox 0.0.3

A library implementing the bittorrent protocol and a few key extensions.
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

//! Unified interface for communicating with different trackers.

use std::old_io::{IoResult};
use std::old_io::net::ip::{SocketAddr, IpAddr};

use types::{Timepoint};

pub mod udp;

/// Information pertaining to the swarm we are in.
pub struct AnnounceInfo {
    /// Number of leechers in the swarm.
    pub leechers: i32,
    /// Number of seeders in the swarm.
    pub seeders:  i32,
    /// List of SocketAddrs for remote peers in the swarm.
    pub peers:    Vec<SocketAddr>,
    /// Indicates when to send an update to the tracker.
    pub interval: Timepoint
}

/// Statistics for a specific torrent.
#[derive(Copy)]
pub struct ScrapeInfo {
    /// Number of leechers in the swarm.
    pub leechers:  i32,
    /// Number of seeders in the swarm.
    pub seeders:   i32,
    /// Number of downloads for this torrent.
    pub downloads: i32
}

/// Statistics for our download session.
#[derive(Copy)]
pub struct TransferStatus {
    /// Number of bytes downloaded so far.
    pub downloaded: i64,
    /// Number of bytes left to download.
    pub remaining:  i64,
    /// Number of bytes uploaded so far.
    pub uploaded:   i64
}

/// Interface for communicating with an generic tracker.
pub trait Tracker {
    /// Returns the local ip address that is being used to communicate with the tracker.
    fn local_ip(&mut self) -> IpAddr;

    /// Returns information about the swarm for a particular torrent file without
    /// joining the swarm.
    ///
    /// This is a blocking operation.
    fn send_scrape(&mut self) -> IoResult<ScrapeInfo>;
    
    /// Sends an announce request to the tracker signalling a start event. This request 
    /// enters us into the swarm and we are required to send periodic updates as 
    /// specified by the tracker in order to be kept in the swarm. Periodic updates 
    /// should be sent with update_announce.
    ///
    /// This is a blocking operation.
    fn start_announce(&mut self, remaining: i64) -> IoResult<AnnounceInfo>;
    
    /// Sends an announce request to the tracker signalling an update event. This request
    /// acts as a heartbeat so that the tracker knows we are still connected and wanting
    /// to be kept in the swarm.
    ///
    /// This is a blocking operation.
    fn update_announce(&mut self, status: TransferStatus) -> IoResult<AnnounceInfo>;
    
    /// Sends an announce request to the tracker signalling a stop event. This request
    /// exists to let the tracker know that we are gracefully shutting down and that
    /// it should remove us from the swarm.
    ///
    /// This is a blocking operation.
    fn stop_announce(&mut self, status: TransferStatus) -> IoResult<()>;
    
    /// Sends an announce request to the tracker signalling a completed event. This request
    /// exists to let the tracker know that we have completed our download and wish to
    /// remain in the swarm as a seeder.
    ///
    /// This is a blocking operation.
    fn complete_announce(&mut self, status: TransferStatus) -> IoResult<AnnounceInfo>;
}