bevy_webgate 0.2.0

A web server integration for the Bevy game engine that allows you to easily append a webserver to Bevy.
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

use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

#[derive(Clone, Debug)]
pub(crate) struct ConnectionTracker {
    active_count: Arc<AtomicUsize>,
    total_count: Arc<AtomicUsize>,
}

impl Default for ConnectionTracker {
    fn default() -> Self {
        Self {
            active_count: Arc::new(AtomicUsize::new(0)),
            total_count: Arc::new(AtomicUsize::new(0)),
        }
    }
}

impl ConnectionTracker {
    pub fn new_connection(&self) -> ConnectionGuard {
        self.total_count.fetch_add(1, Ordering::SeqCst);
        self.active_count.fetch_add(1, Ordering::SeqCst);

        ConnectionGuard {
            active_count: Arc::clone(&self.active_count),
        }
    }

    pub fn active_connections(&self) -> usize {
        self.active_count.load(Ordering::Relaxed)
    }

    pub fn total_connections(&self) -> usize {
        self.total_count.load(Ordering::Relaxed)
    }
}

/// RAII guard that automatically decrements active connection count on drop
pub(crate) struct ConnectionGuard {
    active_count: Arc<AtomicUsize>,
}

impl Drop for ConnectionGuard {
    fn drop(&mut self) {
        self.active_count.fetch_sub(1, Ordering::SeqCst);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_connection_tracker_basic() {
        let tracker = ConnectionTracker::default();

        // Initially no connections
        assert_eq!(tracker.active_connections(), 0);
        assert_eq!(tracker.total_connections(), 0);

        // Create first connection
        let guard1 = tracker.new_connection();
        assert_eq!(tracker.active_connections(), 1);
        assert_eq!(tracker.total_connections(), 1);

        // Create second connection
        let guard2 = tracker.new_connection();
        assert_eq!(tracker.active_connections(), 2);
        assert_eq!(tracker.total_connections(), 2);

        // Drop first connection
        drop(guard1);
        assert_eq!(tracker.active_connections(), 1);
        assert_eq!(tracker.total_connections(), 2);

        // Drop second connection
        drop(guard2);
        assert_eq!(tracker.active_connections(), 0);
        assert_eq!(tracker.total_connections(), 2);
    }

    #[test]
    fn test_connection_tracker_clone() {
        let tracker1 = ConnectionTracker::default();
        let tracker2 = tracker1.clone();

        // Both trackers should share the same counters
        let _guard1 = tracker1.new_connection();
        assert_eq!(tracker1.active_connections(), 1);
        assert_eq!(tracker2.active_connections(), 1);

        let _guard2 = tracker2.new_connection();
        assert_eq!(tracker1.active_connections(), 2);
        assert_eq!(tracker2.active_connections(), 2);
        assert_eq!(tracker1.total_connections(), 2);
        assert_eq!(tracker2.total_connections(), 2);
    }

    #[test]
    fn test_connection_guard_raii() {
        let tracker = ConnectionTracker::default();

        {
            let _guard = tracker.new_connection();
            assert_eq!(tracker.active_connections(), 1);
        } // guard goes out of scope here

        // After guard is dropped, active count should be 0
        assert_eq!(tracker.active_connections(), 0);
        assert_eq!(tracker.total_connections(), 1);
    }

    #[test]
    fn test_multiple_guards_drop_order() {
        let tracker = ConnectionTracker::default();

        let guard1 = tracker.new_connection();
        let guard2 = tracker.new_connection();
        let guard3 = tracker.new_connection();

        assert_eq!(tracker.active_connections(), 3);
        assert_eq!(tracker.total_connections(), 3);

        // Drop in different order
        drop(guard2); // Drop middle one first
        assert_eq!(tracker.active_connections(), 2);

        drop(guard3); // Drop last one
        assert_eq!(tracker.active_connections(), 1);

        drop(guard1); // Drop first one last
        assert_eq!(tracker.active_connections(), 0);

        // Total should remain 3
        assert_eq!(tracker.total_connections(), 3);
    }
}