Reduce ValidUntil size; reduce size of various ws structs

aquatic_http/src/workers/socket.rs

@@ -3,13 +3,13 @@ use std::collections::BTreeMap;
 use std::os::unix::prelude::{FromRawFd, IntoRawFd};
 use std::rc::Rc;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 use anyhow::Context;
 use aquatic_common::access_list::{create_access_list_cache, AccessListArcSwap, AccessListCache};
 use aquatic_common::privileges::PrivilegeDropper;
 use aquatic_common::rustls_config::RustlsConfig;
-use aquatic_common::{CanonicalSocketAddr, PanicSentinel};
+use aquatic_common::{CanonicalSocketAddr, PanicSentinel, ServerStartInstant};
 use aquatic_http_protocol::common::InfoHash;
 use aquatic_http_protocol::request::{Request, RequestParseError, ScrapeRequest};
 use aquatic_http_protocol::response::{
@@ -59,6 +59,7 @@ pub async fn run_socket_worker(
     tls_config: Arc<RustlsConfig>,
     request_mesh_builder: MeshBuilder<ChannelRequest, Partial>,
     priv_dropper: PrivilegeDropper,
+    server_start_instant: ServerStartInstant,
 ) {
     let config = Rc::new(config);
     let access_list = state.access_list;
@@ -74,6 +75,7 @@ pub async fn run_socket_worker(
         clean_connections(
             config.clone(),
             connection_slab.clone(),
+            server_start_instant,
         )
     }));
 
@@ -84,7 +86,10 @@ pub async fn run_socket_worker(
             Ok(stream) => {
                 let key = connection_slab.borrow_mut().insert(ConnectionReference {
                     task_handle: None,
-                    valid_until: ValidUntil::new(config.cleaning.max_connection_idle),
+                    valid_until: ValidUntil::new(
+                        server_start_instant,
+                        config.cleaning.max_connection_idle,
+                    ),
                 });
 
                 let task_handle = spawn_local(enclose!((config, access_list, request_senders, tls_config, connection_slab) async move {
@@ -92,6 +97,7 @@ pub async fn run_socket_worker(
                         config,
                         access_list,
                         request_senders,
+                        server_start_instant,
                         ConnectionId(key),
                         tls_config,
                         connection_slab.clone(),
@@ -118,11 +124,12 @@ pub async fn run_socket_worker(
 async fn clean_connections(
     config: Rc<Config>,
     connection_slab: Rc<RefCell<Slab<ConnectionReference>>>,
+    server_start_instant: ServerStartInstant,
 ) -> Option<Duration> {
-    let now = Instant::now();
+    let now = server_start_instant.seconds_elapsed();
 
     connection_slab.borrow_mut().retain(|_, reference| {
-        if reference.valid_until.0 > now {
+        if reference.valid_until.valid(now) {
             true
         } else {
             if let Some(ref handle) = reference.task_handle {
@@ -145,6 +152,7 @@ struct Connection {
     access_list_cache: AccessListCache,
     request_senders: Rc<Senders<ChannelRequest>>,
     connection_slab: Rc<RefCell<Slab<ConnectionReference>>>,
+    server_start_instant: ServerStartInstant,
     stream: TlsStream<TcpStream>,
     peer_addr: CanonicalSocketAddr,
     connection_id: ConnectionId,
@@ -158,6 +166,7 @@ impl Connection {
         config: Rc<Config>,
         access_list: Arc<AccessListArcSwap>,
         request_senders: Rc<Senders<ChannelRequest>>,
+        server_start_instant: ServerStartInstant,
         connection_id: ConnectionId,
         tls_config: Arc<RustlsConfig>,
         connection_slab: Rc<RefCell<Slab<ConnectionReference>>>,
@@ -180,6 +189,7 @@ impl Connection {
             access_list_cache: create_access_list_cache(&access_list),
             request_senders: request_senders.clone(),
             connection_slab,
+            server_start_instant,
             stream,
             peer_addr,
             connection_id,
@@ -271,7 +281,10 @@ impl Connection {
     async fn handle_request(&mut self, request: Request) -> anyhow::Result<Response> {
         if let Ok(mut slab) = self.connection_slab.try_borrow_mut() {
             if let Some(reference) = slab.get_mut(self.connection_id.0) {
-                reference.valid_until = ValidUntil::new(self.config.cleaning.max_connection_idle);
+                reference.valid_until = ValidUntil::new(
+                    self.server_start_instant,
+                    self.config.cleaning.max_connection_idle,
+                );
             }
         }
 

aquatic_http/src/workers/swarm.rs

@@ -4,7 +4,6 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::Duration;
-use std::time::Instant;
 
 use either::Either;
 use futures_lite::{Stream, StreamExt};
@@ -17,9 +16,9 @@ use rand::SeedableRng;
 use smartstring::{LazyCompact, SmartString};
 
 use aquatic_common::access_list::{create_access_list_cache, AccessListArcSwap, AccessListCache};
-use aquatic_common::ValidUntil;
 use aquatic_common::{extract_response_peers, PanicSentinel};
 use aquatic_common::{AmortizedIndexMap, CanonicalSocketAddr};
+use aquatic_common::{SecondsSinceServerStart, ServerStartInstant, ValidUntil};
 use aquatic_http_protocol::common::*;
 use aquatic_http_protocol::request::*;
 use aquatic_http_protocol::response::ResponsePeer;
@@ -107,20 +106,26 @@ pub struct TorrentMaps {
 }
 
 impl TorrentMaps {
-    pub fn clean(&mut self, config: &Config, access_list: &Arc<AccessListArcSwap>) {
+    pub fn clean(
+        &mut self,
+        config: &Config,
+        access_list: &Arc<AccessListArcSwap>,
+        server_start_instant: ServerStartInstant,
+    ) {
         let mut access_list_cache = create_access_list_cache(access_list);
 
-        Self::clean_torrent_map(config, &mut access_list_cache, &mut self.ipv4);
-        Self::clean_torrent_map(config, &mut access_list_cache, &mut self.ipv6);
+        let now = server_start_instant.seconds_elapsed();
+
+        Self::clean_torrent_map(config, &mut access_list_cache, &mut self.ipv4, now);
+        Self::clean_torrent_map(config, &mut access_list_cache, &mut self.ipv6, now);
     }
 
     fn clean_torrent_map<I: Ip>(
         config: &Config,
         access_list_cache: &mut AccessListCache,
         torrent_map: &mut TorrentMap<I>,
+        now: SecondsSinceServerStart,
     ) {
-        let now = Instant::now();
-
         torrent_map.retain(|info_hash, torrent_data| {
             if !access_list_cache
                 .load()
@@ -133,7 +138,7 @@ impl TorrentMaps {
             let num_leechers = &mut torrent_data.num_leechers;
 
             torrent_data.peers.retain(|_, peer| {
-                let keep = peer.valid_until.0 >= now;
+                let keep = peer.valid_until.valid(now);
 
                 if !keep {
                     match peer.status {
@@ -162,6 +167,7 @@ pub async fn run_swarm_worker(
     config: Config,
     state: State,
     request_mesh_builder: MeshBuilder<ChannelRequest, Partial>,
+    server_start_instant: ServerStartInstant,
 ) {
     let (_, mut request_receivers) = request_mesh_builder.join(Role::Consumer).await.unwrap();
 
@@ -171,19 +177,22 @@ pub async fn run_swarm_worker(
     // Periodically clean torrents
     TimerActionRepeat::repeat(enclose!((config, torrents, access_list) move || {
         enclose!((config, torrents, access_list) move || async move {
-            torrents.borrow_mut().clean(&config, &access_list);
+            torrents.borrow_mut().clean(&config, &access_list, server_start_instant);
 
             Some(Duration::from_secs(config.cleaning.torrent_cleaning_interval))
         })()
     }));
 
     let max_peer_age = config.cleaning.max_peer_age;
-    let peer_valid_until = Rc::new(RefCell::new(ValidUntil::new(max_peer_age)));
+    let peer_valid_until = Rc::new(RefCell::new(ValidUntil::new(
+        server_start_instant,
+        max_peer_age,
+    )));
 
     // Periodically update peer_valid_until
     TimerActionRepeat::repeat(enclose!((peer_valid_until) move || {
         enclose!((peer_valid_until) move || async move {
-            *peer_valid_until.borrow_mut() = ValidUntil::new(max_peer_age);
+            *peer_valid_until.borrow_mut() = ValidUntil::new(server_start_instant, max_peer_age);
 
             Some(Duration::from_secs(1))
         })()