lib

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

scope.rs (6069B)


      1 //! Local disposal inventory only; the common session owns protocol membership.
      2 
      3 use crate::state::Shared;
      4 use futures::{future::poll_fn, lock::Mutex as AsyncMutex};
      5 use radroots_transport::host::websocket::Error;
      6 use std::{
      7     sync::{Arc, Mutex, Weak},
      8     task::Poll,
      9 };
     10 
     11 const MAX_SOCKET_OWNERS: usize = 64;
     12 
     13 #[derive(Default)]
     14 struct State {
     15     closed: bool,
     16     owners: Vec<Weak<Shared>>,
     17 }
     18 
     19 #[derive(Default)]
     20 pub(crate) struct Scope {
     21     state: Mutex<State>,
     22     closing: AsyncMutex<()>,
     23 }
     24 
     25 impl Scope {
     26     pub(crate) fn register(&self, owner: &Arc<Shared>) -> Result<(), Error> {
     27         let mut state = self.state.lock().map_err(|_| Error::Closed)?;
     28         if state.closed {
     29             return Err(Error::Closed);
     30         }
     31         // Weak entries confer no lifetime or effect authority. Do not drop a
     32         // last strong owner or call foreign callbacks while holding this lock.
     33         state.owners.retain(|owner| owner.strong_count() != 0);
     34         if state.owners.len() == MAX_SOCKET_OWNERS {
     35             return Err(Error::Policy);
     36         }
     37         state.owners.push(Arc::downgrade(owner));
     38         Ok(())
     39     }
     40 
     41     pub(crate) async fn close(&self) -> Result<(), Error> {
     42         let _closing = self.closing.lock().await;
     43         let owners: Vec<_> = {
     44             let mut state = self.state.lock().map_err(|_| Error::Closed)?;
     45             state.closed = true;
     46             state.owners.iter().filter_map(Weak::upgrade).collect()
     47         };
     48         for owner in &owners {
     49             owner.stop();
     50         }
     51         for owner in &owners {
     52             poll_fn(|context| {
     53                 owner.scope_closer.register(context.waker());
     54                 let finished = owner.lock()?.finished;
     55                 if finished {
     56                     owner.scope_closer.take();
     57                     Poll::Ready(Ok(()))
     58                 } else {
     59                     Poll::Pending
     60                 }
     61             })
     62             .await?;
     63         }
     64         self.state.lock().map_err(|_| Error::Closed)?.owners.clear();
     65         Ok(())
     66     }
     67 }
     68 
     69 #[cfg(test)]
     70 mod tests {
     71     use super::*;
     72     use crate::state::tests::AdmissionCounter;
     73     use futures::{
     74         FutureExt,
     75         task::{ArcWake, waker},
     76     };
     77     use std::{
     78         future::Future,
     79         sync::atomic::{AtomicUsize, Ordering},
     80         task::Context,
     81     };
     82     fn owner() -> Arc<Shared> {
     83         Arc::new(Shared::new(AdmissionCounter::new(true), 8))
     84     }
     85 
     86     #[test]
     87     fn empty_and_unpolled_close_are_inert_until_observed_and_then_permanent() {
     88         let scope = Scope::default();
     89         drop(scope.close());
     90         let socket = owner();
     91         scope.register(&socket).unwrap();
     92         socket.finish();
     93         futures::executor::block_on(scope.close()).unwrap();
     94         futures::executor::block_on(scope.close()).unwrap();
     95         assert_eq!(scope.register(&owner()), Err(Error::Closed));
     96         futures::executor::block_on(Scope::default().close()).unwrap();
     97     }
     98 
     99     #[test]
    100     fn registration_is_bounded_and_dropped_owners_release_inventory_credit() {
    101         let scope = Scope::default();
    102         let mut held = Vec::new();
    103         for _ in 0..MAX_SOCKET_OWNERS {
    104             let socket = owner();
    105             scope.register(&socket).unwrap();
    106             held.push(socket);
    107         }
    108         let extra = owner();
    109         assert_eq!(scope.register(&extra), Err(Error::Policy));
    110         held.pop();
    111         scope.register(&extra).unwrap();
    112         assert_eq!(scope.state.lock().unwrap().owners.len(), MAX_SOCKET_OWNERS);
    113     }
    114 
    115     #[test]
    116     fn cancelled_close_retains_all_original_owners_and_does_not_affect_a_sibling() {
    117         let scope = Scope::default();
    118         let sibling = Scope::default();
    119         let a = owner();
    120         let b = owner();
    121         let other = owner();
    122         scope.register(&a).unwrap();
    123         scope.register(&b).unwrap();
    124         sibling.register(&other).unwrap();
    125         let mut close = Box::pin(scope.close());
    126         assert!(close.as_mut().now_or_never().is_none());
    127         assert!(a.lock().unwrap().stopping && b.lock().unwrap().stopping);
    128         assert!(!other.lock().unwrap().stopping);
    129         assert_eq!(scope.register(&owner()), Err(Error::Closed));
    130         drop(close);
    131         a.finish();
    132         let mut retry = Box::pin(scope.close());
    133         assert!(retry.as_mut().now_or_never().is_none());
    134         b.finish();
    135         futures::executor::block_on(retry).unwrap();
    136         assert!(!other.lock().unwrap().stopping);
    137     }
    138 
    139     #[test]
    140     fn socket_and_scope_close_observers_have_independent_completion_wakes() {
    141         struct Count(AtomicUsize);
    142         impl ArcWake for Count {
    143             fn wake_by_ref(this: &Arc<Self>) {
    144                 this.0.fetch_add(1, Ordering::SeqCst);
    145             }
    146         }
    147         let scope = Scope::default();
    148         let socket = owner();
    149         scope.register(&socket).unwrap();
    150         let scope_count = Arc::new(Count(AtomicUsize::new(0)));
    151         let socket_count = Arc::new(Count(AtomicUsize::new(0)));
    152         let scope_waker = waker(scope_count.clone());
    153         let socket_waker = waker(socket_count.clone());
    154         let mut close = Box::pin(scope.close());
    155         assert!(
    156             close
    157                 .as_mut()
    158                 .poll(&mut Context::from_waker(&scope_waker))
    159                 .is_pending()
    160         );
    161         socket.closer.register(&socket_waker);
    162         socket.finish();
    163         assert!(scope_count.0.load(Ordering::SeqCst) > 0);
    164         assert!(socket_count.0.load(Ordering::SeqCst) > 0);
    165         futures::executor::block_on(close).unwrap();
    166     }
    167 
    168     #[test]
    169     fn poisoned_inventory_never_claims_disposal_or_admits_another_owner() {
    170         let scope = Scope::default();
    171         let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
    172             let _guard = scope.state.lock().unwrap();
    173             panic!("intentional scope poison");
    174         }));
    175         assert_eq!(scope.register(&owner()), Err(Error::Closed));
    176         assert_eq!(
    177             futures::executor::block_on(scope.close()),
    178             Err(Error::Closed)
    179         );
    180     }
    181 }