lib

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

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 }