client_session.rs (11866B)
1 #![cfg(all(feature = "client_session", not(target_arch = "wasm32")))] 2 3 use core::{ 4 future::Future, 5 num::NonZeroU16, 6 task::{Context, Poll}, 7 }; 8 use futures::{ 9 executor::block_on, 10 future::poll_fn, 11 task::{AtomicWaker, noop_waker_ref}, 12 }; 13 use radroots_execution::{ 14 Code, 15 session::{ClientSession, HostFuture, SessionHost, SessionState}, 16 }; 17 use radroots_identity::PublicKey; 18 use radroots_signing::{ 19 SignReceipt, SignRequest, Signer, SignerStatus, 20 provider::{ 21 ParticipantProvider, PrivateCiphertext, PrivateCryptoCapability, PrivateText, ProviderCall, 22 ProviderError, ProviderState, SignerCallbacks, SignerHandle, 23 }, 24 recovery::ReplayCapability, 25 signer::BoxFuture, 26 }; 27 use std::sync::{ 28 Arc, Mutex, 29 atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering}, 30 }; 31 32 type Trace = Arc<Mutex<Vec<&'static str>>>; 33 struct Host(Trace); 34 impl Host { 35 fn run(&self, name: &'static str) -> HostFuture<'_, radroots_execution::Result<()>> { 36 Box::pin(async move { 37 self.0.lock().unwrap().push(name); 38 Ok(()) 39 }) 40 } 41 } 42 impl SessionHost for Host { 43 fn start(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 44 self.run("start") 45 } 46 fn quiesce(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 47 self.run("quiesce") 48 } 49 fn disconnect(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 50 self.run("disconnect") 51 } 52 fn dispose_callbacks(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 53 self.run("host_callbacks") 54 } 55 fn close_storage(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 56 self.run("storage") 57 } 58 } 59 struct Provider { 60 trace: Trace, 61 mode: AtomicU8, 62 calls: AtomicUsize, 63 quiesced: AtomicBool, 64 fail_quiesce: AtomicBool, 65 wake: AtomicWaker, 66 } 67 impl Signer for Provider { 68 fn status(&self) -> BoxFuture<'_, Result<SignerStatus, radroots_signing::Error>> { 69 Box::pin(async { Ok(SignerStatus::unavailable()) }) 70 } 71 fn sign(&self, _: SignRequest) -> BoxFuture<'_, Result<SignReceipt, radroots_signing::Error>> { 72 Box::pin(async { 73 Err(radroots_signing::Error::new( 74 radroots_signing::error::Kind::SignerUnavailable, 75 )) 76 }) 77 } 78 } 79 impl ParticipantProvider for Provider { 80 fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> { 81 Box::pin(async move { 82 self.calls.fetch_add(1, Ordering::SeqCst); 83 poll_fn(|cx| { 84 self.wake.register(cx.waker()); 85 if self.quiesced.load(Ordering::SeqCst) { 86 return Poll::Ready(Err(ProviderError::Cancelled)); 87 } 88 match self.mode.load(Ordering::SeqCst) { 89 0 => Poll::Ready(Err(ProviderError::CapabilityUnavailable)), 90 2 => Poll::Pending, 91 3 => Poll::Ready(Err(ProviderError::IdentityChanged)), 92 _ => Poll::Ready(Ok(ProviderState::new( 93 PublicKey::from_hex( 94 "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", 95 ) 96 .unwrap(), 97 PrivateCryptoCapability::Unavailable, 98 PrivateCryptoCapability::Unavailable, 99 ReplayCapability::NonReplayable, 100 ))), 101 } 102 }) 103 .await 104 }) 105 } 106 fn encrypt_private( 107 &self, 108 _: ProviderCall, 109 _: PublicKey, 110 _: PrivateText, 111 ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> { 112 Box::pin(async { Err(ProviderError::CapabilityUnavailable) }) 113 } 114 fn decrypt_private( 115 &self, 116 _: ProviderCall, 117 _: PublicKey, 118 _: PrivateCiphertext, 119 ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> { 120 Box::pin(async { Err(ProviderError::CapabilityUnavailable) }) 121 } 122 } 123 impl SignerCallbacks for Provider { 124 fn quiesce(&self) -> BoxFuture<'_, Result<(), ProviderError>> { 125 Box::pin(async move { 126 self.trace.lock().unwrap().push("signer_quiesce"); 127 if self.fail_quiesce.swap(false, Ordering::SeqCst) { 128 return Err(ProviderError::ProviderFailure); 129 } 130 self.quiesced.store(true, Ordering::SeqCst); 131 self.wake.wake(); 132 Ok(()) 133 }) 134 } 135 fn close(&self) -> BoxFuture<'_, Result<(), ProviderError>> { 136 Box::pin(async move { 137 self.trace.lock().unwrap().push("signer_callbacks"); 138 Ok(()) 139 }) 140 } 141 } 142 fn provider(trace: &Trace, mode: u8) -> Arc<Provider> { 143 Arc::new(Provider { 144 trace: trace.clone(), 145 mode: AtomicU8::new(mode), 146 calls: AtomicUsize::new(0), 147 quiesced: AtomicBool::new(false), 148 fail_quiesce: AtomicBool::new(false), 149 wake: AtomicWaker::new(), 150 }) 151 } 152 fn handle(provider: &Arc<Provider>) -> SignerHandle { 153 SignerHandle::new(provider.clone(), provider.clone()) 154 } 155 fn client(trace: &Trace) -> ClientSession<Host> { 156 ClientSession::new(Host(trace.clone()), NonZeroU16::MIN) 157 } 158 159 #[test] 160 fn attachment_before_start_is_owned_and_closed_in_the_actual_composition_order() { 161 let trace = Trace::default(); 162 let client = client(&trace); 163 let provider = provider(&trace, 1); 164 assert_eq!(provider.calls.load(Ordering::SeqCst), 0); 165 let scope = block_on(client.attach_signer(handle(&provider))).unwrap(); 166 assert!(trace.lock().unwrap().is_empty()); 167 assert_eq!(client.state(), SessionState::Ready); 168 assert!(client.signer_session().unwrap().observed().is_some()); 169 assert!(block_on(client.attach_signer(handle(&provider))).is_err()); 170 assert_eq!(provider.calls.load(Ordering::SeqCst), 1); 171 block_on(client.start()).unwrap(); 172 block_on(client.clone().close()).unwrap(); 173 block_on(client.close()).unwrap(); 174 assert_eq!(scope.state(), SessionState::Closed); 175 assert_eq!( 176 *trace.lock().unwrap(), 177 [ 178 "start", 179 "quiesce", 180 "signer_quiesce", 181 "disconnect", 182 "signer_callbacks", 183 "host_callbacks", 184 "storage" 185 ] 186 ); 187 assert!(block_on(client.attach_signer(handle(&provider))).is_err()); 188 assert_eq!(provider.calls.load(Ordering::SeqCst), 1); 189 } 190 191 #[test] 192 fn close_quiesces_a_pending_attachment_before_waiting_for_its_resource_permit() { 193 let trace = Trace::default(); 194 let client = client(&trace); 195 let provider = provider(&trace, 2); 196 let mut attach = Box::pin(client.attach_signer(handle(&provider))); 197 let mut cx = Context::from_waker(noop_waker_ref()); 198 assert!(attach.as_mut().poll(&mut cx).is_pending()); 199 assert!(client.signer_session().is_some()); 200 let mut close = Box::pin(client.close()); 201 assert!(close.as_mut().poll(&mut cx).is_pending()); 202 assert_eq!(client.state(), SessionState::Closing); 203 assert!(matches!(attach.as_mut().poll(&mut cx), Poll::Ready(Err(_)))); 204 assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(())))); 205 assert_eq!( 206 *trace.lock().unwrap(), 207 [ 208 "quiesce", 209 "signer_quiesce", 210 "disconnect", 211 "signer_callbacks", 212 "host_callbacks", 213 "storage" 214 ] 215 ); 216 } 217 218 #[test] 219 fn failed_and_cancelled_attachment_remain_reachable_and_explicitly_replaceable() { 220 for mode in [0, 2, 3] { 221 let trace = Trace::default(); 222 let client = client(&trace); 223 let original = provider(&trace, mode); 224 if mode == 2 { 225 let mut attach = Box::pin(client.attach_signer(handle(&original))); 226 assert!( 227 attach 228 .as_mut() 229 .poll(&mut Context::from_waker(noop_waker_ref())) 230 .is_pending() 231 ); 232 drop(attach); 233 } else { 234 let error = match block_on(client.attach_signer(handle(&original))) { 235 Err(error) => error, 236 Ok(_) => panic!("failed observation accepted"), 237 }; 238 assert_eq!( 239 error.code(), 240 if mode == 3 { 241 Code::IdentityChanged 242 } else { 243 Code::SignerUnavailable 244 } 245 ); 246 } 247 let retained = client.signer_session().unwrap(); 248 assert!(retained.observed().is_none()); 249 block_on(retained.close()).unwrap(); 250 let replacement = provider(&trace, 1); 251 assert!( 252 block_on(client.attach_signer(handle(&replacement))) 253 .unwrap() 254 .observed() 255 .is_some() 256 ); 257 block_on(client.close()).unwrap(); 258 } 259 } 260 261 #[test] 262 fn resuming_signer_quiesce_does_not_repeat_the_completed_host_hook() { 263 let trace = Trace::default(); 264 let client = client(&trace); 265 let provider = provider(&trace, 1); 266 block_on(client.attach_signer(handle(&provider))).unwrap(); 267 provider.fail_quiesce.store(true, Ordering::SeqCst); 268 assert!(block_on(client.close()).is_err()); 269 assert_eq!(*trace.lock().unwrap(), ["quiesce", "signer_quiesce"]); 270 block_on(client.close()).unwrap(); 271 assert_eq!( 272 *trace.lock().unwrap(), 273 [ 274 "quiesce", 275 "signer_quiesce", 276 "signer_quiesce", 277 "disconnect", 278 "signer_callbacks", 279 "host_callbacks", 280 "storage" 281 ] 282 ); 283 let no_signer = self::client(&Trace::default()); 284 assert!(no_signer.signer_session().is_none()); 285 block_on(no_signer.close()).unwrap(); 286 } 287 288 #[test] 289 fn overlapping_attachment_and_close_never_publish_an_unquiesced_scope() { 290 use std::{ 291 sync::{Barrier, mpsc}, 292 thread, 293 time::Duration, 294 }; 295 for _ in 0..32 { 296 let trace = Trace::default(); 297 let client = client(&trace); 298 let provider = provider(&trace, 1); 299 let barrier = Arc::new(Barrier::new(3)); 300 let (attached, observation) = mpsc::sync_channel(1); 301 let (closed, completion) = mpsc::sync_channel(1); 302 let joining = { 303 let client = client.clone(); 304 let provider = provider.clone(); 305 let barrier = barrier.clone(); 306 thread::spawn(move || { 307 barrier.wait(); 308 attached 309 .send(block_on(client.attach_signer(handle(&provider)))) 310 .unwrap(); 311 }) 312 }; 313 let closing = { 314 let client = client.clone(); 315 let barrier = barrier.clone(); 316 thread::spawn(move || { 317 barrier.wait(); 318 closed.send(block_on(client.close())).unwrap(); 319 }) 320 }; 321 barrier.wait(); 322 let scope = observation 323 .recv_timeout(Duration::from_secs(10)) 324 .expect("attachment completed"); 325 completion 326 .recv_timeout(Duration::from_secs(10)) 327 .expect("close completed") 328 .unwrap(); 329 joining.join().unwrap(); 330 closing.join().unwrap(); 331 assert_eq!(client.state(), SessionState::Closed); 332 if let Ok(scope) = scope { 333 assert_eq!(scope.state(), SessionState::Closed); 334 } 335 if let Some(scope) = client.signer_session() { 336 assert_eq!(scope.state(), SessionState::Closed); 337 } 338 assert!(provider.calls.load(Ordering::SeqCst) <= 1); 339 let trace = trace.lock().unwrap(); 340 assert_eq!(trace.last(), Some(&"storage")); 341 if let Some(callback) = trace.iter().position(|item| *item == "signer_callbacks") { 342 assert!(callback < trace.iter().position(|item| *item == "storage").unwrap()); 343 } 344 } 345 }