lib

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

host_bounds.rs (11021B)


      1 //! Compile the complete port thread bounds, with representative local adapters.
      2 //! These unavailable adapters prove host composition, not durable execution.
      3 
      4 #[cfg(not(target_arch = "wasm32"))]
      5 #[test]
      6 fn every_native_port_retains_its_thread_guarantees() {
      7     use radroots_storage as store;
      8     fn send_sync<T: Send + Sync + ?Sized>() {}
      9     fn send<T: Send + ?Sized>() {}
     10     send_sync::<dyn radroots_signing::Signer>();
     11     send_sync::<dyn radroots_signing::provider::ParticipantProvider>();
     12     send_sync::<dyn radroots_signing::provider::NonceSource>();
     13     send_sync::<dyn radroots_signing::CurrentAuthoringAuthority>();
     14     send_sync::<dyn radroots_signing::request::ProgressObserver>();
     15     send_sync::<dyn radroots_transport::EventSource>();
     16     send_sync::<dyn radroots_transport::EventSink>();
     17     send_sync::<dyn radroots_transport::EventSubscriber>();
     18     send::<dyn radroots_transport::EventSubscription>();
     19     send_sync::<dyn store::EventStore>();
     20     send_sync::<dyn store::Journal>();
     21     send_sync::<dyn store::Outbox>();
     22     send_sync::<dyn store::ProjectionStore>();
     23     send_sync::<dyn store::private_artifact::PrivateArtifactStore>();
     24     send_sync::<dyn store::backup::StorageReliability>();
     25     send_sync::<dyn store::authored_draft::AuthoredDraftStore>();
     26     send_sync::<dyn store::atomic::AtomicStorage>();
     27     send_sync::<dyn store::authored_atomic::AuthoredAtomicStorage>();
     28     send_sync::<dyn store::status::StorageStatusProvider>();
     29     send_sync::<dyn radroots_sync::policy::Clock>();
     30     send_sync::<dyn radroots_sync::policy::IdSource>();
     31     send_sync::<radroots_sync::Engine>();
     32     send::<radroots_signing::signer::BoxFuture<'static, ()>>();
     33     send::<radroots_transport::BoxFuture<'static, ()>>();
     34 }
     35 
     36 #[cfg(target_arch = "wasm32")]
     37 mod browser {
     38     use radroots_signing::{self as signing, host::Shared as SignerHandle};
     39     use radroots_storage::{self as store, event::*};
     40     use radroots_sync::policy::{Clock, IdSource, OperationKind, SyncId};
     41     use radroots_transport::{
     42         self as transport, BoxFuture, EventSink, EventSource, EventSubscriber,
     43     };
     44     use std::{cell::Cell, rc::Rc};
     45 
     46     struct Local(Rc<Cell<usize>>);
     47 
     48     impl Local {
     49         fn failed<T: 'static, E: 'static>(&self, error: E) -> BoxFuture<'_, Result<T, E>> {
     50             Box::pin(async move {
     51                 self.0.set(self.0.get() + 1);
     52                 Err(error)
     53             })
     54         }
     55     }
     56 
     57     impl signing::Signer for Local {
     58         fn status(
     59             &self,
     60         ) -> signing::signer::BoxFuture<'_, Result<signing::SignerStatus, signing::Error>> {
     61             self.failed(signing::Error::new(signing::error::Kind::SignerUnavailable))
     62         }
     63         fn sign(
     64             &self,
     65             _: signing::SignRequest,
     66         ) -> signing::signer::BoxFuture<'_, Result<signing::SignReceipt, signing::Error>> {
     67             self.failed(signing::Error::new(signing::error::Kind::SignerUnavailable))
     68         }
     69     }
     70     impl signing::provider::NonceSource for Local {
     71         fn next_nonce(&self) -> Result<[u8; 32], signing::provider::ProviderError> {
     72             self.0.set(self.0.get() + 1);
     73             Err(signing::provider::ProviderError::CapabilityUnavailable)
     74         }
     75     }
     76     impl signing::provider::ParticipantProvider for Local {
     77         fn provider_state(
     78             &self,
     79         ) -> signing::signer::BoxFuture<
     80             '_,
     81             Result<signing::provider::ProviderState, signing::provider::ProviderError>,
     82         > {
     83             self.failed(signing::provider::ProviderError::CapabilityUnavailable)
     84         }
     85         fn encrypt_private(
     86             &self,
     87             _: signing::provider::ProviderCall,
     88             _: radroots_identity::PublicKey,
     89             _: signing::provider::PrivateText,
     90         ) -> signing::signer::BoxFuture<
     91             '_,
     92             Result<signing::provider::PrivateCiphertext, signing::provider::ProviderError>,
     93         > {
     94             self.failed(signing::provider::ProviderError::CapabilityUnavailable)
     95         }
     96         fn decrypt_private(
     97             &self,
     98             _: signing::provider::ProviderCall,
     99             _: radroots_identity::PublicKey,
    100             _: signing::provider::PrivateCiphertext,
    101         ) -> signing::signer::BoxFuture<
    102             '_,
    103             Result<signing::provider::PrivateText, signing::provider::ProviderError>,
    104         > {
    105             self.failed(signing::provider::ProviderError::CapabilityUnavailable)
    106         }
    107     }
    108     impl signing::request::ProgressObserver for Local {
    109         fn on_progress(&self, _: &signing::status::SignProgress) {
    110             self.0.set(self.0.get() + 1);
    111         }
    112     }
    113     impl signing::CurrentAuthoringAuthority for Local {
    114         fn evaluate(
    115             &self,
    116             _: &radroots_event_codec::authoring::AuthoredEventPlan,
    117         ) -> signing::CurrentAuthoringDecision {
    118             signing::CurrentAuthoringDecision::Blocked {
    119                 code: "unavailable",
    120             }
    121         }
    122     }
    123     impl EventSource for Local {
    124         fn status(&self) -> BoxFuture<'_, Result<transport::SourceStatus, transport::Error>> {
    125             self.failed(transport::Error::TransportUnavailable)
    126         }
    127         fn fetch(
    128             &self,
    129             _: transport::FetchRequest,
    130         ) -> BoxFuture<'_, Result<transport::FetchPage, transport::Error>> {
    131             self.failed(transport::Error::TransportUnavailable)
    132         }
    133     }
    134     impl EventSink for Local {
    135         fn status(&self) -> BoxFuture<'_, Result<transport::SinkStatus, transport::Error>> {
    136             self.failed(transport::Error::TransportUnavailable)
    137         }
    138         fn deliver(
    139             &self,
    140             request: transport::DeliveryRequest,
    141         ) -> BoxFuture<'_, Result<transport::DeliveryReceipt, transport::SinkFailure>> {
    142             self.failed(transport::SinkFailure::transport_unavailable(&request))
    143         }
    144     }
    145     impl EventSubscriber for Local {
    146         fn subscribe(
    147             &self,
    148             _: transport::SubscriptionRequest,
    149         ) -> BoxFuture<'_, Result<transport::BoxSubscription, transport::Error>> {
    150             self.failed(transport::Error::SubscriptionUnavailable)
    151         }
    152     }
    153     struct Subscription {
    154         local: Local,
    155         request: transport::SubscriptionRequest,
    156     }
    157     impl transport::EventSubscription for Subscription {
    158         fn request(&self) -> &transport::SubscriptionRequest {
    159             &self.request
    160         }
    161         fn next(&mut self) -> BoxFuture<'_, Result<transport::SubscriptionNext, transport::Error>> {
    162             self.local.failed(transport::Error::TransportUnavailable)
    163         }
    164         fn cancel(
    165             &mut self,
    166         ) -> BoxFuture<'_, Result<transport::SubscriptionEnd, transport::Error>> {
    167             self.local.failed(transport::Error::TransportUnavailable)
    168         }
    169     }
    170     impl Clock for Local {
    171         fn now_unix_ms(&self) -> Result<u64, radroots_sync::Error> {
    172             self.0.set(self.0.get() + 1);
    173             Err(radroots_sync::Error::ClockUnavailable)
    174         }
    175     }
    176     impl IdSource for Local {
    177         fn next_id(&self, _: OperationKind) -> Result<SyncId, radroots_sync::Error> {
    178             self.0.set(self.0.get() + 1);
    179             Err(radroots_sync::Error::InvalidSyncId)
    180         }
    181     }
    182     impl store::EventStore for Local {
    183         fn status(&self) -> BoxFuture<'_, Result<store::status::EventStoreStatus, store::Error>> {
    184             self.failed(store::Error::BackendUnavailable)
    185         }
    186         fn admit(
    187             &self,
    188             _: EventAdmission,
    189         ) -> BoxFuture<'_, Result<AdmissionReceipt, store::Error>> {
    190             self.failed(store::Error::BackendUnavailable)
    191         }
    192         fn query_raw(
    193             &self,
    194             _: EventQuery,
    195         ) -> BoxFuture<'_, Result<EventPage<StoredRawEvent>, store::Error>> {
    196             self.failed(store::Error::BackendUnavailable)
    197         }
    198         fn query_verified(
    199             &self,
    200             _: EventQuery,
    201         ) -> BoxFuture<'_, Result<EventPage<StoredVerifiedEvent>, store::Error>> {
    202             self.failed(store::Error::BackendUnavailable)
    203         }
    204         fn query_visible(
    205             &self,
    206             _: EventQuery,
    207         ) -> BoxFuture<'_, Result<EventPage<StoredVisibleEvent>, store::Error>> {
    208             self.failed(store::Error::BackendUnavailable)
    209         }
    210         fn rebuild_visibility(&self) -> BoxFuture<'_, Result<VisibilitySnapshot, store::Error>> {
    211             self.failed(store::Error::BackendUnavailable)
    212         }
    213         fn query_provenance(
    214             &self,
    215             _: radroots_event::EventId,
    216             _: EventQueryBounds,
    217         ) -> BoxFuture<'_, Result<EventPage<StoredEventProvenance>, store::Error>> {
    218             self.failed(store::Error::BackendUnavailable)
    219         }
    220     }
    221     impl store::status::StorageStatusProvider for Local {
    222         fn storage_status(
    223             &self,
    224         ) -> BoxFuture<'_, Result<store::status::StorageStatus, store::Error>> {
    225             self.failed(store::Error::BackendUnavailable)
    226         }
    227     }
    228 
    229     #[test]
    230     fn browser_ports_accept_real_local_callback_and_future_state() {
    231         let state = Rc::new(Cell::new(0));
    232         let signer: signing::signer::DynSigner = SignerHandle::new(Local(state.clone()));
    233         let participant: SignerHandle<dyn signing::provider::ParticipantProvider> =
    234             SignerHandle::new(Local(state.clone()));
    235         let nonces: SignerHandle<dyn signing::provider::NonceSource> =
    236             SignerHandle::new(Local(state.clone()));
    237         let source: transport::host::Shared<dyn EventSource> = Rc::new(Local(state.clone()));
    238         let sink: transport::host::Shared<dyn EventSink> = Rc::new(Local(state.clone()));
    239         let subscriber: transport::host::Shared<dyn EventSubscriber> =
    240             Rc::new(Local(state.clone()));
    241         let store: Rc<dyn store::EventStore> = Rc::new(Local(state.clone()));
    242         let observer: SignerHandle<dyn signing::request::ProgressObserver> =
    243             Rc::new(Local(state.clone()));
    244         let authority: Rc<dyn signing::CurrentAuthoringAuthority> = Rc::new(Local(state.clone()));
    245         let clock: transport::host::Shared<dyn Clock> = Rc::new(Local(state.clone()));
    246         let ids: transport::host::Shared<dyn IdSource> = Rc::new(Local(state.clone()));
    247         drop((sink, subscriber, observer, authority, clock, ids, nonces));
    248         futures::executor::block_on(async {
    249             assert!(signer.status().await.is_err());
    250             assert!(participant.provider_state().await.is_err());
    251             assert!(source.status().await.is_err());
    252             assert!(store.status().await.is_err());
    253         });
    254         assert_eq!(state.get(), 4);
    255         fn owned_subscription(
    256             request: transport::SubscriptionRequest,
    257             state: Rc<Cell<usize>>,
    258         ) -> transport::BoxSubscription {
    259             Box::new(Subscription {
    260                 local: Local(state),
    261                 request,
    262             })
    263         }
    264         let _constructor = owned_subscription;
    265     }
    266 }