freenet 0.2.48

Freenet core software
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
145
146
147
148
149

use std::collections::VecDeque;
use std::time::Duration;
use tokio::time::Instant;

/// `ConnectionEvaluator` is used to evaluate connection scores within a specified time window.
///
/// The evaluator records scores and determines whether a given score is better (higher) than
/// any other scores within a predefined time window. A score is considered better if it's higher
/// than all other scores in the time window, or if no scores were recorded within the window's
/// duration.
///
/// In the Freenet context, this will be used to titrate the rate of new connection requests accepted
/// by a node. The node will only accept a new connection if the score of the connection is better
/// than all other scores within the time window.
pub(super) struct ConnectionEvaluator {
    scores: VecDeque<(Instant, f64)>,
    window_duration: Duration,
}

impl ConnectionEvaluator {
    pub fn new(window_duration: Duration) -> Self {
        ConnectionEvaluator {
            scores: VecDeque::new(),
            window_duration,
        }
    }

    pub fn record_only_with_current_time(&mut self, score: f64, current_time: Instant) {
        self.remove_outdated_scores(current_time);
        self.scores.push_back((current_time, score));
    }

    pub fn record_and_eval_with_current_time(&mut self, score: f64, current_time: Instant) -> bool {
        self.remove_outdated_scores(current_time);

        let is_better = self.scores.is_empty() || self.scores.iter().all(|&(_, s)| score > s);

        // Important to add new score *after* checking if it's better than all other scores
        self.record_only_with_current_time(score, current_time);

        is_better
    }

    fn remove_outdated_scores(&mut self, current_time: Instant) {
        while let Some(&(time, _)) = self.scores.front() {
            if current_time.duration_since(time) > self.window_duration {
                self.scores.pop_front();
            } else {
                break;
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_record_first_score() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(10));
        let current_time = Instant::now();
        assert!(evaluator.record_and_eval_with_current_time(5.0, current_time));
        // Assert evaluator.scores contains the new score
        assert_eq!(evaluator.scores.len(), 1);
        assert_eq!(evaluator.scores[0].1, 5.0);
        assert_eq!(evaluator.scores[0].0, current_time);
    }

    #[test]
    fn test_not_best_in_time_window() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(10));

        let start_time = Instant::now();
        evaluator.record_and_eval_with_current_time(5.0, start_time);
        assert!(
            !evaluator.record_and_eval_with_current_time(4.0, start_time + Duration::from_secs(5)),
        );
    }

    #[test]
    fn test_best_in_time_window() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(10));

        let start_time = Instant::now();
        evaluator.record_and_eval_with_current_time(5.0, start_time);
        assert!(
            evaluator.record_and_eval_with_current_time(4.0, start_time + Duration::from_secs(11)),
        );
    }

    #[test]
    fn test_remove_outdated_scores() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(10));

        let start_time = Instant::now();
        evaluator.record_and_eval_with_current_time(5.0, start_time);
        evaluator.record_and_eval_with_current_time(6.0, start_time + Duration::from_secs(5));
        evaluator.record_and_eval_with_current_time(4.5, start_time + Duration::from_secs(11));
        assert_eq!(evaluator.scores.len(), 2);
    }

    #[test]
    fn test_empty_window_duration() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(0));
        let current_time = Instant::now();
        assert!(evaluator.record_and_eval_with_current_time(5.0, current_time));
        assert!(!evaluator.record_and_eval_with_current_time(4.0, current_time));
    }

    #[test]
    fn test_multiple_scores_same_timestamp() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(10));
        let current_time = Instant::now();
        evaluator.record_only_with_current_time(5.0, current_time);
        evaluator.record_only_with_current_time(6.0, current_time);
        assert_eq!(evaluator.scores.len(), 2);
        assert!(
            !evaluator
                .record_and_eval_with_current_time(4.0, current_time + Duration::from_secs(5)),
        );
    }

    #[test]
    fn test_negative_scores() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(10));
        let start_time = Instant::now();
        assert!(evaluator.record_and_eval_with_current_time(-5.0, start_time),);
        assert!(
            evaluator.record_and_eval_with_current_time(-4.0, start_time + Duration::from_secs(5)),
        );
        assert!(
            !evaluator.record_and_eval_with_current_time(-6.0, start_time + Duration::from_secs(5)),
        );
    }

    #[test]
    fn test_large_number_of_scores() {
        let mut evaluator = ConnectionEvaluator::new(Duration::from_secs(10));
        let start_time = Instant::now();
        for i in 0..1000 {
            evaluator.record_only_with_current_time(i as f64, start_time + Duration::from_secs(i));
        }
        assert!(
            evaluator
                .record_and_eval_with_current_time(1000.0, start_time + Duration::from_secs(1001)),
        );
    }
}