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 }