torrust-tracker-configuration 3.0.0

A library to provide configuration to the Torrust 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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use derive_more::{Constructor, Display};
use serde::{Deserialize, Serialize};

use super::network::Network;
use crate::v2_0_0::database::Database;
use crate::validator::{SemanticValidationError, Validator};
use crate::{AnnouncePolicy, TrackerPolicy};

#[allow(clippy::struct_excessive_bools)]
#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
pub struct Core {
    /// Announce policy configuration.
    #[serde(default = "Core::default_announce_policy")]
    pub announce_policy: AnnouncePolicy,

    /// Database configuration.
    #[serde(default = "Core::default_database")]
    pub database: Database,

    /// Interval in seconds that the cleanup job will run to remove inactive
    /// peers from the torrent peer list.
    #[serde(default = "Core::default_inactive_peer_cleanup_interval")]
    pub inactive_peer_cleanup_interval: u64,

    /// When `true` only approved torrents can be announced in the tracker.
    #[serde(default = "Core::default_listed")]
    pub listed: bool,

    /// Network configuration.
    #[serde(default = "Core::default_network")]
    pub net: Network,

    /// When `true` clients require a key to connect and use the tracker.
    #[serde(default = "Core::default_private")]
    pub private: bool,

    /// Configuration specific when the tracker is running in private mode.
    #[serde(default = "Core::default_private_mode")]
    pub private_mode: Option<PrivateMode>,

    /// Tracker policy configuration.
    #[serde(default = "Core::default_tracker_policy")]
    pub tracker_policy: TrackerPolicy,

    /// Weather the tracker should collect statistics about tracker usage.
    /// If enabled, the tracker will collect statistics like the number of
    /// connections handled, the number of announce requests handled, etc.
    /// Refer to the [`Tracker`](https://docs.rs/torrust-tracker) for more
    /// information about the collected metrics.
    #[serde(default = "Core::default_tracker_usage_statistics")]
    pub tracker_usage_statistics: bool,
}

impl Default for Core {
    fn default() -> Self {
        Self {
            announce_policy: Self::default_announce_policy(),
            database: Self::default_database(),
            inactive_peer_cleanup_interval: Self::default_inactive_peer_cleanup_interval(),
            listed: Self::default_listed(),
            net: Self::default_network(),
            private: Self::default_private(),
            private_mode: Self::default_private_mode(),
            tracker_policy: Self::default_tracker_policy(),
            tracker_usage_statistics: Self::default_tracker_usage_statistics(),
        }
    }
}

impl Core {
    fn default_announce_policy() -> AnnouncePolicy {
        AnnouncePolicy::default()
    }

    fn default_database() -> Database {
        Database::default()
    }

    fn default_inactive_peer_cleanup_interval() -> u64 {
        600
    }

    fn default_listed() -> bool {
        false
    }

    fn default_network() -> Network {
        Network::default()
    }

    fn default_private() -> bool {
        false
    }

    fn default_private_mode() -> Option<PrivateMode> {
        if Self::default_private() {
            Some(PrivateMode::default())
        } else {
            None
        }
    }

    fn default_tracker_policy() -> TrackerPolicy {
        TrackerPolicy::default()
    }
    fn default_tracker_usage_statistics() -> bool {
        true
    }
}

/// Configuration specific when the tracker is running in private mode.
#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Copy, Constructor, Display)]
pub struct PrivateMode {
    /// A flag to disable expiration date for peer keys.
    ///
    /// When true, if the keys is not permanent the expiration date will be
    /// ignored. The key will be accepted even if it has expired.
    #[serde(default = "PrivateMode::default_check_keys_expiration")]
    pub check_keys_expiration: bool,
}

impl Default for PrivateMode {
    fn default() -> Self {
        Self {
            check_keys_expiration: Self::default_check_keys_expiration(),
        }
    }
}

impl PrivateMode {
    fn default_check_keys_expiration() -> bool {
        true
    }
}

impl Validator for Core {
    fn validate(&self) -> Result<(), SemanticValidationError> {
        if self.private_mode.is_some() && !self.private {
            return Err(SemanticValidationError::UselessPrivateModeSection);
        }

        Ok(())
    }
}