内存优化

tests/test_session.rs

@@ -5,8 +5,9 @@ use std::fs::File;
 use std::io::BufReader;
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 
+use arc_swap::ArcSwap;
 use rustls::{ClientConfig, RootCertStore};
 use rustls_pki_types::{CertificateDer, PrivateKeyDer, ServerName};
 use serde_json::json;
@@ -37,7 +38,7 @@ use rpki::rtr::server::tls::load_rustls_server_config_with_options;
 use rpki::rtr::session::RtrSession;
 
 fn shared_cache(cache: rpki::rtr::cache::RtrCache) -> SharedRtrCache {
-    Arc::new(RwLock::new(cache))
+    Arc::new(ArcSwap::from_pointee(cache))
 }
 
 async fn start_session_server(
@@ -450,7 +451,7 @@ async fn restart_restores_versioned_state_and_serves_queries() {
     ResetQuery::new(0).write(&mut client).await.unwrap();
     let response = CacheResponse::read(&mut client).await.unwrap();
     assert_eq!(response.version(), 0);
-    let expected_sid_v0 = shared.read().unwrap().session_id_for_version(0);
+    let expected_sid_v0 = shared.load_full().session_id_for_version(0);
     assert_eq!(response.session_id(), expected_sid_v0);
     let _v4 = IPv4Prefix::read(&mut client).await.unwrap();
     let eod_v0 = rpki::rtr::pdu::EndOfDataV0::read(&mut client).await.unwrap();
@@ -462,7 +463,7 @@ async fn restart_restores_versioned_state_and_serves_queries() {
     ResetQuery::new(1).write(&mut client).await.unwrap();
     let response = CacheResponse::read(&mut client).await.unwrap();
     assert_eq!(response.version(), 1);
-    let expected_sid_v1 = shared.read().unwrap().session_id_for_version(1);
+    let expected_sid_v1 = shared.load_full().session_id_for_version(1);
     assert_eq!(response.session_id(), expected_sid_v1);
     let _v4 = IPv4Prefix::read(&mut client).await.unwrap();
     let _rk = RouterKeyPdu::read(&mut client).await.unwrap();
@@ -472,7 +473,7 @@ async fn restart_restores_versioned_state_and_serves_queries() {
 
     let (addr, _notify_tx, shutdown_tx, server_handle) = start_session_server(shared.clone()).await;
     let mut client = TcpStream::connect(addr).await.unwrap();
-    let sid_v2 = shared.read().unwrap().session_id_for_version(2);
+    let sid_v2 = shared.load_full().session_id_for_version(2);
     SerialQuery::new(2, sid_v2, 1).write(&mut client).await.unwrap();
     let response = CacheResponse::read(&mut client).await.unwrap();
     assert_eq!(response.version(), 2);
@@ -1654,7 +1655,7 @@ async fn version_one_sends_router_key_but_not_aspa() {
 }
 
 #[tokio::test]
-async fn established_session_idle_timeout_returns_transport_failed() {
+async fn established_session_idle_does_not_trigger_transport_failed() {
     let cache = RtrCacheBuilder::new()
         .session_ids(SessionIds::from_array([42, 42, 42]))
         .serials(serials_all(100))
@@ -1675,38 +1676,20 @@ async fn established_session_idle_timeout_returns_transport_failed() {
     let eod = EndOfDataV1::read(&mut client).await.unwrap();
     dump.push_value(eod.pdu(), dump_eod_v1(&eod));
 
-    let report = timeout(Duration::from_secs(1), ErrorReport::read(&mut client))
-        .await
-        .expect("timed out waiting for transport failure ErrorReport")
-        .unwrap();
-    dump.push_value(
-        ErrorReport::PDU,
-        json!({
-            "version": report.version(),
-            "pdu": ErrorReport::PDU,
-            "pdu_name": "Error Report",
-            "error_code": report.error_code().map(|code| code.as_u16()).unwrap_or_else(|code| code),
-            "erroneous_pdu_len": report.erroneous_pdu().len(),
-            "erroneous_pdu_hex": common::test_helper::bytes_to_hex(report.erroneous_pdu()),
-            "text": String::from_utf8_lossy(report.text()),
-        }),
+    let idle_res = timeout(Duration::from_millis(300), Header::read(&mut client)).await;
+    assert!(
+        idle_res.is_err(),
+        "established session should stay idle without sending TransportFailed"
     );
-
-    assert_eq!(report.version(), 1);
-    assert_eq!(report.error_code(), Ok(ErrorCode::TransportFailed));
-    assert!(report.erroneous_pdu().is_empty());
-    assert!(std::str::from_utf8(report.text()).unwrap().contains("transport stalled"));
-
-    let read_res = Header::read(&mut client).await;
-    assert!(read_res.is_err());
     dump.push_value(
         0,
         json!({
-            "event": "connection_closed_after_transport_timeout",
-            "result": "header_read_failed_as_expected"
+            "event": "no_transport_failed_on_established_idle",
+            "result": "no_pdu_received_within_timeout",
+            "timeout_ms": 300
         }),
     );
-    dump.print_pretty("established_session_idle_timeout_returns_transport_failed");
+    dump.print_pretty("established_session_idle_does_not_trigger_transport_failed");
 
     shutdown_server(client, shutdown_tx, server_handle).await;
 }