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 }