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 }