lib

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

test_host.rs (5028B)


      1 //! Test-only loopback I/O for private shared-session lifecycle witnesses.
      2 //! Charges complete frames for shared cleanup tests. Actual native policy, TLS
      3 //! and predecode byte/frame budgets run in the native provider suite.
      4 
      5 use futures::{
      6     SinkExt, StreamExt,
      7     lock::Mutex,
      8     stream::{SplitSink, SplitStream},
      9 };
     10 use radroots_transport::host::websocket::{Admission, Connector, Error, Frame, IoFuture, Socket};
     11 use std::{num::NonZeroUsize, sync::Arc, time::Duration};
     12 use tokio::net::TcpStream;
     13 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, tungstenite::Message};
     14 
     15 #[derive(Debug)]
     16 pub(crate) struct LoopbackConnector;
     17 
     18 pub(crate) fn transport(config: crate::Config) -> crate::NostrTransport {
     19     crate::NostrTransport::new(config, Arc::new(LoopbackConnector))
     20 }
     21 
     22 impl Connector for LoopbackConnector {
     23     fn supports_ping(&self) -> bool {
     24         true
     25     }
     26     fn connect<'a>(
     27         &'a self,
     28         endpoint: &'a str,
     29         timeout: Duration,
     30         _: NonZeroUsize,
     31         admission: Arc<dyn Admission>,
     32     ) -> IoFuture<'a, Result<Arc<dyn Socket>, Error>> {
     33         Box::pin(async move {
     34             let url = url::Url::parse(endpoint).map_err(|_| Error::Policy)?;
     35             let ip = url
     36                 .host_str()
     37                 .and_then(|host| host.parse::<std::net::IpAddr>().ok())
     38                 .ok_or(Error::Policy)?;
     39             if url.scheme() != "ws" || !ip.is_loopback() || !admission.permits_address(ip) {
     40                 return Err(Error::Policy);
     41             }
     42             let (socket, _) =
     43                 tokio::time::timeout(timeout, tokio_tungstenite::connect_async(endpoint))
     44                     .await
     45                     .map_err(|_| Error::Timeout)?
     46                     .map_err(|_| Error::Unavailable)?;
     47             let (sink, stream) = socket.split();
     48             Ok(Arc::new(LoopbackSocket {
     49                 sink: Mutex::new(sink),
     50                 stream: Mutex::new(stream),
     51                 admission,
     52             }) as Arc<dyn Socket>)
     53         })
     54     }
     55 }
     56 
     57 type Wire = WebSocketStream<MaybeTlsStream<TcpStream>>;
     58 struct LoopbackSocket {
     59     sink: Mutex<SplitSink<Wire, Message>>,
     60     stream: Mutex<SplitStream<Wire>>,
     61     admission: Arc<dyn Admission>,
     62 }
     63 
     64 impl Socket for LoopbackSocket {
     65     fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> {
     66         Box::pin(async move {
     67             futures::future::poll_fn(|context| {
     68                 std::task::Poll::Ready(if self.admission.admitted_write(context) {
     69                     Ok(())
     70                 } else {
     71                     Err(Error::Closed)
     72                 })
     73             })
     74             .await?;
     75             let message = match frame {
     76                 Frame::Text(text) => Message::Text(text.into()),
     77                 Frame::Binary(bytes) => Message::Binary(bytes.into()),
     78                 Frame::Ping(bytes) => Message::Ping(bytes.into()),
     79                 Frame::Pong(bytes) => Message::Pong(bytes.into()),
     80                 Frame::Close(None) => Message::Close(None),
     81                 _ => return Err(Error::Unsupported),
     82             };
     83             self.sink
     84                 .lock()
     85                 .await
     86                 .send(message)
     87                 .await
     88                 .map_err(|_| Error::Unavailable)
     89         })
     90     }
     91     fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> {
     92         Box::pin(async move {
     93             let mut stream = self.stream.lock().await;
     94             let message = futures::future::poll_fn(|context| {
     95                 if !self.admission.admitted_read(context) {
     96                     return std::task::Poll::Ready(Some(Err(
     97                         tokio_tungstenite::tungstenite::Error::ConnectionClosed,
     98                     )));
     99                 }
    100                 stream.poll_next_unpin(context)
    101             })
    102             .await
    103             .transpose()
    104             .map_err(|_| Error::Unavailable)?;
    105             message
    106                 .map(|message| {
    107                     let data = matches!(message, Message::Text(_) | Message::Binary(_));
    108                     if !self.admission.charge(message.len(), 1, usize::from(data)) {
    109                         return Err(Error::Closed);
    110                     }
    111                     Ok(match message {
    112                         Message::Text(text) => Frame::Text(text.to_string()),
    113                         Message::Binary(bytes) => Frame::Binary(bytes.to_vec()),
    114                         Message::Ping(bytes) => Frame::Ping(bytes.to_vec()),
    115                         Message::Pong(bytes) => Frame::Pong(bytes.to_vec()),
    116                         Message::Close(_) => Frame::Close(None),
    117                         Message::Frame(_) => return Err(Error::Protocol),
    118                     })
    119                 })
    120                 .transpose()
    121         })
    122     }
    123     fn close(&self) -> IoFuture<'_, Result<(), Error>> {
    124         Box::pin(async move {
    125             self.sink
    126                 .lock()
    127                 .await
    128                 .close()
    129                 .await
    130                 .map_err(|_| Error::Unavailable)
    131         })
    132     }
    133 }