relay.rs (8199B)
1 use crate::{FixtureError, FixturePolicy, now}; 2 use futures::{SinkExt, StreamExt}; 3 use nostr::JsonUtil; 4 use radroots_transport::{ 5 policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, 6 target::Target, 7 }; 8 use radroots_transport_nostr::{ 9 Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, 10 }; 11 use serde_json::{Value, value::RawValue}; 12 use std::sync::{ 13 Arc, Mutex, 14 atomic::{AtomicBool, AtomicU64, Ordering}, 15 }; 16 use tokio::{ 17 net::TcpListener, 18 sync::oneshot, 19 task::{JoinHandle, JoinSet}, 20 }; 21 use tokio_tungstenite::{ 22 accept_async_with_config, 23 tungstenite::{Message, protocol::WebSocketConfig}, 24 }; 25 26 pub(crate) struct Relay { 27 pub url: String, 28 pub policy: SatisfactionPolicy, 29 pub events: Arc<Mutex<Vec<String>>>, 30 pub reads: Arc<AtomicU64>, 31 pub accepting: Arc<AtomicBool>, 32 stop: Mutex<Option<oneshot::Sender<()>>>, 33 task: Mutex<Option<JoinHandle<()>>>, 34 } 35 impl Relay { 36 pub async fn new(selected: FixturePolicy) -> Result<Self, FixtureError> { 37 let listener = TcpListener::bind("127.0.0.1:0") 38 .await 39 .map_err(|_| FixtureError::Unavailable)?; 40 let url = format!( 41 "ws://{}", 42 listener 43 .local_addr() 44 .map_err(|_| FixtureError::Unavailable)? 45 ); 46 let sources = Arc::new([advertisement(1, &url)?, advertisement(2, &url)?]); 47 let policy = match selected { 48 FixturePolicy::All => TargetPolicy::all(), 49 FixturePolicy::Any => TargetPolicy::any(), 50 FixturePolicy::Quorum => { 51 TargetPolicy::quorum(1).map_err(|_| FixtureError::Unavailable)? 52 } 53 FixturePolicy::Required => TargetPolicy::required(vec![ 54 Target::nostr_relay(&url) 55 .map_err(|_| FixtureError::Unavailable)? 56 .fingerprint() 57 .clone(), 58 ]) 59 .map_err(|_| FixtureError::Unavailable)?, 60 }; 61 let policy = SatisfactionPolicy::new(SatisfactionClass::Accepted, policy); 62 let events = Arc::new(Mutex::new(Vec::new())); 63 let received = events.clone(); 64 let reads = Arc::new(AtomicU64::new(0)); 65 let requests = reads.clone(); 66 let accepting = Arc::new(AtomicBool::new(true)); 67 let accepted = accepting.clone(); 68 let (stop, mut stopped) = oneshot::channel(); 69 let task = tokio::spawn(async move { 70 let mut clients = JoinSet::new(); 71 loop { 72 tokio::select! { 73 _ = &mut stopped => break, 74 _ = clients.join_next(), if !clients.is_empty() => {}, 75 connection = listener.accept() => { 76 let Ok((tcp, _)) = connection else { break }; 77 if clients.len() >= 16 { continue; } 78 let sources = sources.clone(); let events = received.clone(); let reads = requests.clone(); let accepting = accepted.clone(); 79 clients.spawn(async move { 80 let config = WebSocketConfig::default().max_message_size(Some(65_600)).max_frame_size(Some(65_600)); 81 let Ok(mut socket) = accept_async_with_config(tcp, Some(config)).await else { return }; 82 while let Some(Ok(message)) = socket.next().await { 83 let Message::Text(raw) = message else { continue }; 84 let Ok(frame) = serde_json::from_str::<Vec<&RawValue>>(&raw) else { break }; 85 match frame.first().map(|v| v.get()) { 86 Some("\"REQ\"") if frame.len() >= 3 => { 87 reads.fetch_add(1, Ordering::SeqCst); 88 let Ok(filter) = serde_json::from_str::<Value>(frame[2].get()) else { break }; 89 let author = filter["authors"][0].as_str(); 90 for source in sources.iter() { 91 let event: Value = serde_json::from_str(source).expect("synthetic event"); 92 if event["pubkey"].as_str() == author && socket.send(Message::Text(format!("[\"EVENT\",{},{}]", frame[1].get(), source).into())).await.is_err() { return; } 93 } 94 if socket.send(Message::Text(format!("[\"EOSE\",{}]", frame[1].get()).into())).await.is_err() { return; } 95 } 96 Some("\"EVENT\"") if frame.len() == 2 => { 97 let original = frame[1].get(); 98 let Ok(event) = nostr::Event::from_json(original) else { break }; 99 if event.verify().is_err() { break; } 100 { 101 let mut retained = events.lock().expect("fixture events"); 102 let bytes: usize = retained.iter().map(String::len).sum(); 103 if bytes + original.len() > 4 * 1024 * 1024 { return; } 104 retained.push(original.to_owned()); 105 } 106 let accepted = accepting.load(Ordering::SeqCst); 107 let reason = if accepted { "" } else { "blocked: measured loopback rejection" }; 108 let ack = serde_json::json!(["OK", event.id.to_hex(), accepted, reason]); 109 if socket.send(Message::Text(ack.to_string().into())).await.is_err() { return; } 110 } 111 _ => {} 112 } 113 } 114 }); 115 } 116 } 117 } 118 clients.abort_all(); 119 while clients.join_next().await.is_some() {} 120 }); 121 Ok(Self { 122 url, 123 policy, 124 events, 125 reads, 126 accepting, 127 stop: Mutex::new(Some(stop)), 128 task: Mutex::new(Some(task)), 129 }) 130 } 131 pub fn config(&self) -> Result<Config, FixtureError> { 132 let endpoint = RelayEndpoint::new(&self.url, RelayUrlPolicy::Local, RelayAccess::ReadWrite) 133 .map_err(|_| FixtureError::Unavailable)?; 134 let profile = RelayProfile::explicit(RelayProfileKind::Simulator, [endpoint]) 135 .map_err(|_| FixtureError::Unavailable)?; 136 Config::from_profile(profile) 137 .with_timeouts(2000, 2000, 2000) 138 .map_err(|_| FixtureError::Unavailable) 139 } 140 pub async fn stop(&self) -> Result<(), FixtureError> { 141 if let Some(stop) = self 142 .stop 143 .lock() 144 .map_err(|_| FixtureError::Unavailable)? 145 .take() 146 { 147 let _ = stop.send(()); 148 } 149 let task = self 150 .task 151 .lock() 152 .map_err(|_| FixtureError::Unavailable)? 153 .take(); 154 if let Some(task) = task { 155 task.await.map_err(|_| FixtureError::Unavailable)?; 156 } 157 Ok(()) 158 } 159 } 160 fn advertisement(last: u8, url: &str) -> Result<String, FixtureError> { 161 let mut scalar = [0; 32]; 162 scalar[31] = last; 163 let keys = nostr::Keys::new( 164 nostr::SecretKey::from_slice(&scalar).map_err(|_| FixtureError::Unavailable)?, 165 ); 166 nostr::UnsignedEvent { 167 id: None, 168 pubkey: keys.public_key(), 169 created_at: nostr::Timestamp::from_secs(now()?.saturating_sub(1)), 170 kind: nostr::Kind::Custom(10050), 171 tags: nostr::Tags::from_list(vec![ 172 nostr::Tag::parse(["relay", url]).map_err(|_| FixtureError::Unavailable)?, 173 ]), 174 content: String::new(), 175 } 176 .sign_with_keys(&keys) 177 .map(|v| v.as_json()) 178 .map_err(|_| FixtureError::Unavailable) 179 }