hyprstream_rpc/transport/
lazy_quinn.rs1use std::net::SocketAddr;
28use std::time::Duration;
29
30use anyhow::{anyhow, bail, Result};
31use async_trait::async_trait;
32use tokio::sync::Mutex;
33
34use crate::transport::backoff::LazyState;
35use crate::transport::quinn_transport::{
36 connect_pinned_hashes, connect_webpki, verify_peer_cert_pinned, QuinnPendingStream,
37 QuinnPublishStub, QuinnTransport,
38};
39use crate::transport::QuicServerAuth;
40use crate::transport_traits::Transport;
41
42const DEFAULT_TIMEOUT: Duration = Duration::from_secs(30);
45
46const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
50
51pub struct LazyQuinnTransport {
53 addr: SocketAddr,
54 server_name: String,
55 auth: QuicServerAuth,
56 state: Mutex<LazyState<QuinnTransport>>,
60}
61
62impl LazyQuinnTransport {
63 pub fn new(addr: SocketAddr, server_name: impl Into<String>, auth: QuicServerAuth) -> Self {
67 Self {
68 addr,
69 server_name: server_name.into(),
70 auth,
71 state: Mutex::new(LazyState::default()),
72 }
73 }
74
75 async fn connected(&self) -> Result<QuinnTransport> {
79 let mut guard = self.state.lock().await;
80 if let Some(transport) = guard.cached.as_ref() {
81 return Ok(transport.clone());
82 }
83 if let Some(remaining) = guard.backoff.cooldown_remaining() {
84 return Err(anyhow!(
85 "quinn peer is in reconnect backoff — retry in {remaining:.1?}"
86 ));
87 }
88 let connect = async {
89 let hashes = self.auth.accept_cert_hashes();
90 match (self.auth.require_web_pki(), hashes.is_empty()) {
91 (true, true) => connect_webpki(&self.server_name, self.addr.port()).await,
92 (false, false) => connect_pinned_hashes(self.addr, hashes).await,
93 (true, false) => {
94 let session = connect_webpki(&self.server_name, self.addr.port()).await?;
95 verify_peer_cert_pinned(&session, hashes)?;
96 Ok(session)
97 }
98 (false, true) => bail!("QUIC endpoint has no server-auth requirement"),
99 }
100 };
101 match tokio::time::timeout(CONNECT_TIMEOUT, connect).await {
102 Err(_) => {
103 guard.backoff.record_failure();
104 Err(anyhow!("quinn connect timed out after {CONNECT_TIMEOUT:?}"))
105 }
106 Ok(Err(e)) => {
107 guard.backoff.record_failure();
108 Err(e)
109 }
110 Ok(Ok(session)) => {
111 guard.backoff.record_success();
112 let transport = QuinnTransport::new(session);
113 guard.cached = Some(transport.clone());
114 Ok(transport)
115 }
116 }
117 }
118
119 async fn invalidate(&self) {
122 let mut guard = self.state.lock().await;
123 guard.cached = None;
124 guard.backoff.record_failure();
125 }
126}
127
128#[async_trait]
129impl Transport for LazyQuinnTransport {
130 type Sub = QuinnPendingStream;
131 type Pub = QuinnPublishStub;
132
133 async fn send(&self, payload: Vec<u8>, timeout_ms: Option<i32>) -> Result<Vec<u8>> {
134 let transport = self
135 .connected()
136 .await
137 .map_err(crate::transport_traits::PreDispatchTransportError::new)?;
138
139 let deadline = timeout_ms
144 .map(|ms| Duration::from_millis(ms.max(0) as u64))
145 .unwrap_or(DEFAULT_TIMEOUT);
146 let inner_ceiling_ms = deadline.as_millis().saturating_mul(2).min(i32::MAX as u128) as i32;
147
148 match tokio::time::timeout(deadline, transport.send(payload, Some(inner_ceiling_ms))).await
149 {
150 Err(_elapsed) => Err(anyhow!("quinn RPC timeout after {deadline:?}")),
154 Ok(Ok(resp)) => Ok(resp),
155 Ok(Err(e)) => {
158 self.invalidate().await;
159 Err(e)
160 }
161 }
162 }
163
164 fn forbids_cleartext_envelope(&self) -> bool {
171 true
172 }
173
174 async fn subscribe(&self, _topic: &[u8]) -> Result<Self::Sub> {
175 bail!("lazy quinn RPC transport does not support SUB — streaming is on the moq plane")
176 }
177
178 async fn publish(&self, _topic: &[u8]) -> Result<Self::Pub> {
179 bail!("lazy quinn RPC transport does not support PUB — streaming is on the moq plane")
180 }
181}
182
183#[cfg(test)]
184#[allow(clippy::unwrap_used, clippy::expect_used)]
185mod tests {
186 use super::*;
187 use crate::transport::quinn_transport::QuinnRpcServer;
188 use bytes::Bytes;
189 use ed25519_dalek::SigningKey;
190 use rand::RngCore;
191 use std::time::Duration;
192 use tokio_util::sync::CancellationToken;
193
194 fn fresh_signing_key() -> SigningKey {
195 let mut k = [0u8; 32];
196 rand::thread_rng().fill_bytes(&mut k);
197 SigningKey::from_bytes(&k)
198 }
199
200 fn sha256_32(bytes: &[u8]) -> [u8; 32] {
201 use sha2::{Digest, Sha256};
202 let mut h = [0u8; 32];
203 h.copy_from_slice(&Sha256::digest(bytes));
204 h
205 }
206
207 fn spawn_echo_server() -> (SocketAddr, [u8; 32], CancellationToken) {
211 crate::transport::pq_provider::install_pq_crypto_provider().expect("install PQ provider");
212
213 let cert_key = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
214 let cert_der = cert_key.cert.der().to_vec();
215 let key_der = cert_key.key_pair.serialize_der();
216 let chain = vec![rustls::pki_types::CertificateDer::from(cert_der.clone())];
217 let key = rustls::pki_types::PrivateKeyDer::Pkcs8(
218 rustls::pki_types::PrivatePkcs8KeyDer::from(key_der),
219 );
220 let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
221 let server = web_transport_quinn::ServerBuilder::new()
222 .with_addr(addr)
223 .with_certificate(chain, key)
224 .unwrap();
225 let bound = server.local_addr().unwrap();
226
227 let processor = crate::transport::rpc_session::from_fn(|req: Bytes| async move { Ok(req) });
228 let rpc_server =
229 QuinnRpcServer::new(server, processor, fresh_signing_key()).with_test_trusted_carrier();
230 let shutdown = rpc_server.shutdown_token();
231 tokio::spawn(rpc_server.run());
232
233 (bound, sha256_32(&cert_der), shutdown)
234 }
235
236 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
237 async fn lazy_connects_on_first_send_and_caches() {
238 let (addr, pin, shutdown) = spawn_echo_server();
239 let t = LazyQuinnTransport::new(
240 addr,
241 "localhost",
242 QuicServerAuth::pinned(vec![pin]).unwrap(),
243 );
244
245 assert!(
246 t.state.lock().await.cached.is_none(),
247 "no connection before first send"
248 );
249
250 let resp = t.send(b"hello".to_vec(), Some(5_000)).await.unwrap();
251 assert_eq!(resp, b"hello");
252 assert!(
253 t.state.lock().await.cached.is_some(),
254 "session cached after first send"
255 );
256
257 let resp2 = t.send(b"again".to_vec(), Some(5_000)).await.unwrap();
258 assert_eq!(resp2, b"again");
259
260 shutdown.cancel();
261 }
262
263 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
264 async fn wrong_cert_pin_does_not_connect() {
265 let (addr, _pin, shutdown) = spawn_echo_server();
266 let t = LazyQuinnTransport::new(
267 addr,
268 "localhost",
269 QuicServerAuth::pinned(vec![[0u8; 32]]).unwrap(),
270 ); let res = tokio::time::timeout(Duration::from_secs(8), t.send(b"x".to_vec(), Some(3_000)))
275 .await
276 .expect("send must complete (with an error) — a wrong pin should reject, not hang");
277 assert!(res.is_err(), "a wrong cert pin must make send fail");
278 assert!(
279 t.state.lock().await.cached.is_none(),
280 "failed dial leaves nothing cached"
281 );
282 shutdown.cancel();
283 }
284
285 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
286 async fn dead_address_send_fails_fast_not_hang() {
287 let t = LazyQuinnTransport::new(
291 "127.0.0.1:1".parse().unwrap(),
292 "localhost",
293 QuicServerAuth::pinned(vec![[0u8; 32]]).unwrap(),
294 );
295 let res = tokio::time::timeout(Duration::from_secs(13), t.send(b"x".to_vec(), Some(2_000)))
296 .await
297 .expect("send must complete (with an error) within the connect timeout, not hang");
298 assert!(
299 res.is_err(),
300 "a dead address must yield an error, not a connection"
301 );
302 assert!(
303 t.state.lock().await.cached.is_none(),
304 "a failed connect caches nothing"
305 );
306 }
307
308 #[tokio::test]
309 async fn subscribe_publish_bail() {
310 let t = LazyQuinnTransport::new(
311 "127.0.0.1:1".parse().unwrap(),
312 "localhost",
313 QuicServerAuth::pinned(vec![[0u8; 32]]).unwrap(),
314 );
315 assert!(t.subscribe(b"topic").await.is_err());
316 assert!(t.publish(b"topic").await.is_err());
317 }
318}