lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

fetch_raw_budget.rs (10225B)


      1 use futures::{SinkExt, StreamExt};
      2 use radroots_transport::{
      3     EventSource, FetchRequest, TargetSet, outcome::FetchTargetState, source::FetchBounds,
      4 };
      5 use radroots_transport_nostr::{
      6     Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind,
      7     RelayUrlPolicy,
      8 };
      9 use serde_json::Value;
     10 use std::time::{Duration, SystemTime, UNIX_EPOCH};
     11 use tokio::net::{TcpListener, TcpStream};
     12 use tokio_tungstenite::{WebSocketStream, accept_async, tungstenite::Message};
     13 
     14 const WATCHDOG: Duration = Duration::from_secs(10);
     15 
     16 fn transport(urls: &[String]) -> (NostrTransport, FetchRequest) {
     17     let profile = RelayProfile::explicit(
     18         RelayProfileKind::Simulator,
     19         urls.iter().map(|url| {
     20             RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap()
     21         }),
     22     )
     23     .unwrap();
     24     let config = Config::from_profile(profile)
     25         .with_timeouts(1000, 5000, 500)
     26         .unwrap()
     27         .with_max_connections(1)
     28         .unwrap();
     29     let targets = TargetSet::new(
     30         config
     31             .read_relays()
     32             .map(|relay| relay.to_target().unwrap())
     33             .collect(),
     34     )
     35     .unwrap();
     36     let now = SystemTime::now()
     37         .duration_since(UNIX_EPOCH)
     38         .unwrap()
     39         .as_millis() as u64;
     40     let request = FetchRequest::new(
     41         "raw-budget-loopback",
     42         targets,
     43         FetchBounds::new(10, now + 5000).unwrap(),
     44     )
     45     .unwrap();
     46     (
     47         radroots_transport_nostr_native::create_transport(config),
     48         request,
     49     )
     50 }
     51 
     52 async fn listener() -> (TcpListener, String) {
     53     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
     54     let url = format!("ws://{}", listener.local_addr().unwrap());
     55     (listener, url)
     56 }
     57 
     58 fn malformed_event() -> Value {
     59     // Canonical primitive fields pass wire admission, while absent event
     60     // fields still exercise malformed traffic in the aggregate ingress budget.
     61     let value = serde_json::json!({
     62         "id": "00".repeat(32),
     63         "pubkey": "11".repeat(32),
     64         "sig": "22".repeat(64),
     65         "invalid_event": "x".repeat(384 * 1024),
     66     });
     67     assert!(serde_json::from_value::<nostr_sdk::prelude::Event>(value.clone()).is_err());
     68     value
     69 }
     70 
     71 // A WebSocket pong is produced only after the client's receive stream has
     72 // consumed all preceding messages. No scheduling sleep is an admission barrier.
     73 async fn barrier(socket: &mut WebSocketStream<TcpStream>, sequence: usize) -> bool {
     74     let marker = sequence.to_be_bytes().to_vec();
     75     if socket
     76         .send(Message::Ping(marker.clone().into()))
     77         .await
     78         .is_err()
     79     {
     80         return false;
     81     }
     82     while let Some(message) = socket.next().await {
     83         match message {
     84             Ok(Message::Pong(value)) if value.as_ref() == marker.as_slice() => return true,
     85             Ok(Message::Close(_)) | Err(_) => return false,
     86             _ => {
     87                 if socket.flush().await.is_err() {
     88                     return false;
     89                 }
     90             }
     91         }
     92     }
     93     false
     94 }
     95 
     96 async fn serve_malformed(listener: TcpListener, frames: usize) {
     97     let (stream, _) = listener.accept().await.unwrap();
     98     let mut socket = accept_async(stream).await.unwrap();
     99     while let Some(message) = socket.next().await {
    100         let text = match message {
    101             Ok(Message::Text(text)) => text,
    102             Ok(Message::Close(_)) | Err(_) => return,
    103             _ => {
    104                 let _ = socket.flush().await;
    105                 continue;
    106             }
    107         };
    108         let values: Value = serde_json::from_str(&text).unwrap();
    109         if values[0] != "REQ" {
    110             continue;
    111         }
    112         let malformed = serde_json::to_string(&("EVENT", &values[1], malformed_event())).unwrap();
    113         assert!(malformed.len() < 512 * 1024);
    114         for sequence in 0..frames {
    115             if socket
    116                 .send(Message::Text(malformed.clone().into()))
    117                 .await
    118                 .is_err()
    119                 || !barrier(&mut socket, sequence).await
    120             {
    121                 return;
    122             }
    123         }
    124         if socket
    125             .send(Message::Text(
    126                 serde_json::to_string(&("EOSE", &values[1])).unwrap().into(),
    127             ))
    128             .await
    129             .is_err()
    130         {
    131             return;
    132         }
    133     }
    134 }
    135 
    136 async fn fetch_malformed(frames: usize) -> FetchTargetState {
    137     let (listener, url) = listener().await;
    138     let server = tokio::spawn(serve_malformed(listener, frames));
    139     let (transport, request) = transport(&[url]);
    140     let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await;
    141     server.abort();
    142     let joined = server.await;
    143     assert!(joined.is_ok() || joined.unwrap_err().is_cancelled());
    144     let page = result.unwrap().unwrap();
    145     assert!(page.events().is_empty());
    146     assert_eq!(page.target_outcomes().len(), 1);
    147     page.target_outcomes()[0].state()
    148 }
    149 
    150 #[tokio::test(flavor = "multi_thread")]
    151 async fn empty_eose_remains_complete_with_raw_ingress_accounting() {
    152     assert_eq!(fetch_malformed(0).await, FetchTargetState::Complete);
    153 }
    154 
    155 #[tokio::test(flavor = "multi_thread")]
    156 async fn malformed_event_traffic_exhausts_raw_budget_before_eose() {
    157     assert_eq!(fetch_malformed(24).await, FetchTargetState::Partial);
    158 }
    159 
    160 async fn finish_server(mut server: tokio::task::JoinHandle<()>) {
    161     let result = tokio::time::timeout(WATCHDOG, &mut server).await;
    162     if result.is_err() {
    163         server.abort();
    164         let _ = server.await;
    165     }
    166     result
    167         .expect("client must close the bounded relay connection")
    168         .unwrap();
    169 }
    170 
    171 #[tokio::test(flavor = "multi_thread")]
    172 async fn completed_batches_do_not_refund_raw_bytes_for_later_relays() {
    173     let (one, one_url) = listener().await;
    174     let (two, two_url) = listener().await;
    175     let servers = [
    176         tokio::spawn(serve_malformed(one, 12)),
    177         tokio::spawn(serve_malformed(two, 12)),
    178     ];
    179     let (transport, request) = transport(&[one_url, two_url]);
    180     let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await;
    181     for server in servers {
    182         finish_server(server).await;
    183     }
    184     let page = result.unwrap().unwrap();
    185     assert!(page.events().is_empty());
    186     assert_eq!(
    187         page.target_outcomes()
    188             .iter()
    189             .filter(|outcome| outcome.state() == FetchTargetState::Complete)
    190             .count(),
    191         1
    192     );
    193     assert_eq!(
    194         page.target_outcomes()
    195             .iter()
    196             .filter(|outcome| outcome.state() == FetchTargetState::Partial)
    197             .count(),
    198         1
    199     );
    200 }
    201 
    202 #[tokio::test(flavor = "multi_thread")]
    203 async fn unsolicited_malformed_traffic_is_bounded_before_the_request() {
    204     let (listener, url) = listener().await;
    205     let server = tokio::spawn(async move {
    206         let (stream, _) = listener.accept().await.unwrap();
    207         let mut socket = accept_async(stream).await.unwrap();
    208         let malformed =
    209             serde_json::to_string(&("EVENT", "unsolicited", malformed_event())).unwrap();
    210         for sequence in 0..24 {
    211             if socket
    212                 .send(Message::Text(malformed.clone().into()))
    213                 .await
    214                 .is_err()
    215                 || !barrier(&mut socket, sequence).await
    216             {
    217                 return;
    218             }
    219         }
    220         panic!("oversized unsolicited inventory must close before admission");
    221     });
    222     let (transport, request) = transport(&[url]);
    223     let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await;
    224     finish_server(server).await;
    225     assert_eq!(
    226         result.unwrap().unwrap().target_outcomes()[0].state(),
    227         FetchTargetState::Partial
    228     );
    229 }
    230 
    231 #[tokio::test(flavor = "multi_thread")]
    232 async fn zero_payload_continuation_frames_consume_work_before_message_decoding() {
    233     use tokio_tungstenite::tungstenite::protocol::frame::{
    234         Frame,
    235         coding::{Data, OpCode},
    236     };
    237     let (listener, url) = listener().await;
    238     let server = tokio::spawn(async move {
    239         let (stream, _) = listener.accept().await.unwrap();
    240         let mut socket = accept_async(stream).await.unwrap();
    241         while let Some(message) = socket.next().await {
    242             let text = match message {
    243                 Ok(Message::Text(text)) => text,
    244                 Ok(Message::Close(_)) | Err(_) => return,
    245                 _ => {
    246                     let _ = socket.flush().await;
    247                     continue;
    248                 }
    249             };
    250             let values: Value = serde_json::from_str(&text).unwrap();
    251             if values[0] != "REQ" {
    252                 continue;
    253             }
    254             socket
    255                 .send(Message::Frame(Frame::message(
    256                     Vec::new(),
    257                     OpCode::Data(Data::Text),
    258                     false,
    259                 )))
    260                 .await
    261                 .unwrap();
    262             for sequence in 0..8193 {
    263                 if socket
    264                     .send(Message::Frame(Frame::message(
    265                         Vec::new(),
    266                         OpCode::Data(Data::Continue),
    267                         false,
    268                     )))
    269                     .await
    270                     .is_err()
    271                 {
    272                     return;
    273                 }
    274                 if sequence % 128 == 0 && !barrier(&mut socket, sequence).await {
    275                     return;
    276                 }
    277             }
    278             if socket
    279                 .send(Message::Frame(Frame::message(
    280                     b"[]".to_vec(),
    281                     OpCode::Data(Data::Continue),
    282                     true,
    283                 )))
    284                 .await
    285                 .is_err()
    286             {
    287                 return;
    288             }
    289             let _ = socket
    290                 .send(Message::Text(
    291                     serde_json::to_string(&("EOSE", &values[1])).unwrap().into(),
    292                 ))
    293                 .await;
    294         }
    295     });
    296     let (transport, request) = transport(&[url]);
    297     let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await;
    298     finish_server(server).await;
    299     let page = result.unwrap().unwrap();
    300     assert!(page.events().is_empty());
    301     assert_eq!(page.target_outcomes()[0].state(), FetchTargetState::Partial);
    302 }