lib

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

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 }