lib

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

exact_delivery.rs (5858B)


      1 //! Exact retained EVENT framing and connection-local acknowledgement handling.
      2 
      3 use crate::{session_socket::MAX_WIRE_MESSAGE_BYTES, socket_write::WriterRegistry, status};
      4 use futures::StreamExt;
      5 use nostr_sdk::prelude::{EventId, RelayMessage};
      6 use nostr_sdk::relay::{RelayNotification, RelayStatus};
      7 use radroots_transport::{DeliveryRequest, outcome::DeliveryOutcome};
      8 use std::sync::Arc;
      9 
     10 #[derive(Clone)]
     11 pub(crate) struct ExactEvent {
     12     id: EventId,
     13     frame: Arc<str>,
     14 }
     15 
     16 impl ExactEvent {
     17     pub(crate) fn from_request(request: &DeliveryRequest) -> Option<Self> {
     18         let signed = request.payload().event();
     19         let raw = signed.raw_json();
     20         u16::try_from(signed.envelope().kind_u32()).ok()?;
     21         let id = EventId::from_slice(signed.envelope().id().as_bytes()).ok()?;
     22         Some(Self {
     23             id,
     24             frame: frame(raw)?,
     25         })
     26     }
     27 
     28     pub(crate) async fn publish(
     29         &self,
     30         client: &nostr_sdk::client::Client,
     31         writers: &WriterRegistry,
     32         url: &str,
     33     ) -> Result<DeliveryOutcome, String> {
     34         let relay = client
     35             .relay(url)
     36             .await
     37             .map_err(|error| error.to_string())?
     38             .ok_or_else(|| "configured relay is unavailable".to_owned())?;
     39         // Subscribe before sending on the same connection; no success from enqueue alone.
     40         let mut notifications = relay.notifications().with_gaps();
     41         let writer = writers.get(url).map_err(|error| error.to_string())?;
     42         writer
     43             .send(async_wsocket::Message::Text(self.frame.to_string()))
     44             .await
     45             .map_err(|error| error.to_string())?;
     46         loop {
     47             let notification = notifications
     48                 .next()
     49                 .await
     50                 .ok_or_else(|| "relay acknowledgement unavailable".to_owned())?
     51                 .map_err(|_| "relay acknowledgement unavailable".to_owned())?;
     52             if let Some(outcome) = acknowledgement(self.id, notification) {
     53                 return Ok(outcome);
     54             }
     55         }
     56     }
     57 }
     58 
     59 fn frame(raw: &str) -> Option<Arc<str>> {
     60     // Bound before allocation; preserve whitespace, field order and extensions.
     61     (raw.len() <= MAX_WIRE_MESSAGE_BYTES - "[\"EVENT\",]".len())
     62         .then(|| format!("[\"EVENT\",{raw}]").into())
     63 }
     64 
     65 fn acknowledgement(id: EventId, notification: RelayNotification) -> Option<DeliveryOutcome> {
     66     match notification {
     67         RelayNotification::Message { message } => match *message {
     68             RelayMessage::Ok {
     69                 event_id,
     70                 status: accepted,
     71                 message,
     72             } if event_id == id => Some(if accepted {
     73                 DeliveryOutcome::accepted()
     74             } else {
     75                 status::delivery_failure(&message)
     76             }),
     77             _ => None,
     78         },
     79         RelayNotification::RelayStatus {
     80             status: RelayStatus::Disconnected | RelayStatus::Idle | RelayStatus::Banned,
     81         } => Some(status::delivery_failure("relay disconnected")),
     82         RelayNotification::RelayStatus {
     83             status: RelayStatus::Shutdown,
     84         } => Some(status::delivery_failure("relay shutdown")),
     85         _ => None,
     86     }
     87 }
     88 
     89 #[cfg(test)]
     90 mod tests {
     91     use super::*;
     92 
     93     #[test]
     94     fn framing_bounds_complete_message_bytes_before_allocation() {
     95         let limit = MAX_WIRE_MESSAGE_BYTES - "[\"EVENT\",]".len();
     96         let exact = " ".repeat(limit);
     97         assert_eq!(frame(&exact).unwrap().len(), MAX_WIRE_MESSAGE_BYTES);
     98         assert!(frame(&(exact + " ")).is_none());
     99         let unicode = "🌱".repeat(limit / 4 + 1);
    100         assert!(frame(&unicode).is_none());
    101         assert_eq!(
    102             &*frame(" \n{\"extension\":true} \t").unwrap(),
    103             "[\"EVENT\", \n{\"extension\":true} \t]"
    104         );
    105     }
    106 
    107     #[test]
    108     fn only_matching_ok_can_accept_and_disconnects_remain_failures() {
    109         let id = EventId::from_byte_array([1; 32]);
    110         let other = EventId::from_byte_array([2; 32]);
    111         let ok = |event_id, status, message: &'static str| RelayNotification::Message {
    112             message: Box::new(RelayMessage::Ok {
    113                 event_id,
    114                 status,
    115                 message: message.into(),
    116             }),
    117         };
    118         assert!(acknowledgement(id, ok(other, true, "")).is_none());
    119         assert_eq!(
    120             acknowledgement(id, ok(id, true, "")).unwrap(),
    121             DeliveryOutcome::accepted()
    122         );
    123         assert_eq!(
    124             acknowledgement(id, ok(id, true, "duplicate: already have this event")).unwrap(),
    125             DeliveryOutcome::accepted()
    126         );
    127         for message in [
    128             "blocked: denied",
    129             "blocked: not a duplicate; event was rejected",
    130             "duplicate: already have this event",
    131             "already have this event",
    132         ] {
    133             assert!(!status::delivery_succeeded(
    134                 &acknowledgement(id, ok(id, false, message)).unwrap()
    135             ));
    136         }
    137         for status in [
    138             nostr_sdk::relay::RelayStatus::Disconnected,
    139             nostr_sdk::relay::RelayStatus::Idle,
    140             nostr_sdk::relay::RelayStatus::Banned,
    141         ] {
    142             assert!(!super::status::delivery_succeeded(
    143                 &acknowledgement(id, RelayNotification::RelayStatus { status }).unwrap()
    144             ));
    145         }
    146         assert!(
    147             acknowledgement(
    148                 id,
    149                 RelayNotification::RelayStatus {
    150                     status: nostr_sdk::relay::RelayStatus::Connected
    151                 }
    152             )
    153             .is_none()
    154         );
    155         assert!(!status::delivery_succeeded(
    156             &acknowledgement(
    157                 id,
    158                 RelayNotification::RelayStatus {
    159                     status: RelayStatus::Shutdown
    160                 }
    161             )
    162             .unwrap()
    163         ));
    164     }
    165 }