torrust-actix 4.2.3

A rich, fast and efficient Bittorrent Tracker.
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

use crate::stats::enums::stats_event::StatsEvent;
use crate::tracker::enums::updates_action::UpdatesAction;
use crate::tracker::structs::info_hash::InfoHash;
use crate::tracker::structs::torrent_tracker::TorrentTracker;
use log::{
    error,
    info
};
use std::collections::hash_map::Entry;
use std::collections::{
    BTreeMap,
    HashMap
};
use std::sync::Arc;
use std::time::SystemTime;

impl TorrentTracker {
    pub fn add_key_update(&self, info_hash: InfoHash, timeout: i64, updates_action: UpdatesAction) -> bool
    {
        let mut lock = self.keys_updates.write();
        let timestamp = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos();
        if lock.insert(timestamp, (info_hash, timeout, updates_action)).is_none() {
            self.update_stats(StatsEvent::KeyUpdates, 1);
            true
        } else {
            false
        }
    }

    pub fn get_key_updates(&self) -> HashMap<u128, (InfoHash, i64, UpdatesAction)>
    {
        let lock = self.keys_updates.read_recursive();
        lock.clone()
    }

    pub fn remove_key_update(&self, timestamp: &u128) -> bool
    {
        let mut lock = self.keys_updates.write();
        if lock.remove(timestamp).is_some() {
            self.update_stats(StatsEvent::KeyUpdates, -1);
            true
        } else {
            false
        }
    }

    pub fn clear_key_updates(&self)
    {
        let mut lock = self.keys_updates.write();
        lock.clear();
        self.set_stats(StatsEvent::KeyUpdates, 0);
    }

    pub async fn save_key_updates(&self, torrent_tracker: Arc<TorrentTracker>) -> Result<(), ()>
    {
        let updates = self.get_key_updates();
        let mut mapping: HashMap<InfoHash, (u128, i64, UpdatesAction)> = HashMap::new();
        let mut timestamps_to_remove = Vec::new();
        for (timestamp, (info_hash, timeout, updates_action)) in updates {
            match mapping.entry(info_hash) {
                Entry::Occupied(mut o) => {
                    let existing = o.get();
                    if timestamp > existing.0 {
                        timestamps_to_remove.push(existing.0);
                        o.insert((timestamp, timeout, updates_action));
                    } else {
                        timestamps_to_remove.push(timestamp);
                    }
                }
                Entry::Vacant(v) => {
                    v.insert((timestamp, timeout, updates_action));
                }
            }
        }
        let keys_to_save: BTreeMap<InfoHash, (i64, UpdatesAction)> = mapping
            .iter()
            .map(|(info_hash, (_, timeout, updates_action))| (*info_hash, (*timeout, *updates_action)))
            .collect();
        if let Ok(()) = self.save_keys(torrent_tracker, keys_to_save).await {
            info!("[SYNC KEY UPDATES] Synced {} keys", mapping.len());
            for (_, (timestamp, _, _)) in mapping {
                self.remove_key_update(&timestamp);
            }
            for timestamp in timestamps_to_remove {
                self.remove_key_update(&timestamp);
            }
            Ok(())
        } else {
            error!("[SYNC KEY UPDATES] Unable to sync {} keys", mapping.len());
            Err(())
        }
    }
}