|
| 1 | +use core::net::SocketAddr; |
| 2 | +use core::pin::pin; |
| 3 | + |
| 4 | +use std::sync::Arc; |
| 5 | + |
| 6 | +use anyhow::Context as _; |
| 7 | +use clap::Parser; |
| 8 | +use futures::stream::select_all; |
| 9 | +use futures::StreamExt as _; |
| 10 | +use quinn::crypto::rustls::QuicServerConfig; |
| 11 | +use quinn::{Endpoint, ServerConfig}; |
| 12 | +use rcgen::{generate_simple_self_signed, CertifiedKey}; |
| 13 | +use rustls::pki_types::{CertificateDer, PrivatePkcs8KeyDer}; |
| 14 | +use rustls::version::TLS13; |
| 15 | +use tokio::task::JoinSet; |
| 16 | +use tokio::{select, signal}; |
| 17 | +use tracing::{debug, error, info, warn}; |
| 18 | + |
| 19 | +#[derive(Parser, Debug)] |
| 20 | +#[command(author, version, about, long_about = None)] |
| 21 | +struct Args { |
| 22 | + /// Address to serve `wasi:keyvalue` on |
| 23 | + #[arg(default_value = "[::1]:4433")] |
| 24 | + addr: SocketAddr, |
| 25 | +} |
| 26 | + |
| 27 | +#[tokio::main] |
| 28 | +async fn main() -> anyhow::Result<()> { |
| 29 | + tracing_subscriber::fmt().init(); |
| 30 | + |
| 31 | + let Args { addr } = Args::parse(); |
| 32 | + |
| 33 | + let CertifiedKey { cert, key_pair } = generate_simple_self_signed([ |
| 34 | + "localhost".to_string(), |
| 35 | + "::1".to_string(), |
| 36 | + "127.0.0.1".to_string(), |
| 37 | + ]) |
| 38 | + .context("failed to generate server certificate")?; |
| 39 | + let cert = CertificateDer::from(cert); |
| 40 | + |
| 41 | + let conf = rustls::ServerConfig::builder_with_protocol_versions(&[&TLS13]) |
| 42 | + .with_no_client_auth() // TODO: verify client cert |
| 43 | + .with_single_cert( |
| 44 | + vec![cert], |
| 45 | + PrivatePkcs8KeyDer::from(key_pair.serialize_der()).into(), |
| 46 | + ) |
| 47 | + .context("failed to create server config")?; |
| 48 | + |
| 49 | + let conf: QuicServerConfig = conf |
| 50 | + .try_into() |
| 51 | + .context("failed to convert rustls client config to QUIC server config")?; |
| 52 | + |
| 53 | + let ep = Endpoint::server(ServerConfig::with_crypto(Arc::new(conf)), addr) |
| 54 | + .context("failed to create server endpoint")?; |
| 55 | + |
| 56 | + let srv = Arc::new(wrpc_transport_quic::Server::new()); |
| 57 | + let accept = tokio::spawn({ |
| 58 | + let mut tasks = JoinSet::<anyhow::Result<()>>::new(); |
| 59 | + let srv = Arc::clone(&srv); |
| 60 | + async move { |
| 61 | + loop { |
| 62 | + select! { |
| 63 | + Some(conn) = ep.accept() => { |
| 64 | + let srv = Arc::clone(&srv); |
| 65 | + tasks.spawn(async move { |
| 66 | + let conn = conn |
| 67 | + .accept() |
| 68 | + .context("failed to accept QUIC connection")?; |
| 69 | + let conn = conn.await.context("failed to establish QUIC connection")?; |
| 70 | + let wrpc = wrpc_transport_quic::Client::from(conn); |
| 71 | + loop { |
| 72 | + srv.accept(&wrpc) |
| 73 | + .await |
| 74 | + .context("failed to accept wRPC connection")?; |
| 75 | + } |
| 76 | + }); |
| 77 | + } |
| 78 | + Some(res) = tasks.join_next() => { |
| 79 | + match res { |
| 80 | + Ok(Ok(())) => {} |
| 81 | + Ok(Err(err)) => { |
| 82 | + warn!(?err, "failed to serve connection") |
| 83 | + } |
| 84 | + Err(err) => { |
| 85 | + error!(?err, "failed to join task") |
| 86 | + } |
| 87 | + } |
| 88 | + } |
| 89 | + else => { |
| 90 | + return; |
| 91 | + } |
| 92 | + } |
| 93 | + } |
| 94 | + } |
| 95 | + }); |
| 96 | + |
| 97 | + let invocations = |
| 98 | + wrpc_wasi_keyvalue::serve(srv.as_ref(), wrpc_wasi_keyvalue_mem::Handler::default()) |
| 99 | + .await |
| 100 | + .context("failed to serve `wasi:keyvalue`")?; |
| 101 | + // NOTE: This will conflate all invocation streams into a single stream via `futures::stream::SelectAll`, |
| 102 | + // to customize this, iterate over the returned `invocations` and set up custom handling per export |
| 103 | + let mut invocations = select_all( |
| 104 | + invocations |
| 105 | + .into_iter() |
| 106 | + .map(|(instance, name, invocations)| invocations.map(move |res| (instance, name, res))), |
| 107 | + ); |
| 108 | + let shutdown = signal::ctrl_c(); |
| 109 | + let mut shutdown = pin!(shutdown); |
| 110 | + let mut tasks = JoinSet::new(); |
| 111 | + loop { |
| 112 | + select! { |
| 113 | + Some((instance, name, res)) = invocations.next() => { |
| 114 | + match res { |
| 115 | + Ok(fut) => { |
| 116 | + debug!(instance, name, "invocation accepted"); |
| 117 | + tasks.spawn(async move { |
| 118 | + if let Err(err) = fut.await { |
| 119 | + warn!(?err, "failed to handle invocation"); |
| 120 | + } else { |
| 121 | + info!(instance, name, "invocation successfully handled"); |
| 122 | + } |
| 123 | + }); |
| 124 | + } |
| 125 | + Err(err) => { |
| 126 | + warn!(?err, instance, name, "failed to accept invocation"); |
| 127 | + } |
| 128 | + } |
| 129 | + } |
| 130 | + Some(res) = tasks.join_next() => { |
| 131 | + if let Err(err) = res { |
| 132 | + error!(?err, "failed to join task") |
| 133 | + } |
| 134 | + } |
| 135 | + res = &mut shutdown => { |
| 136 | + accept.abort(); |
| 137 | + // wait for all invocations to complete |
| 138 | + while let Some(res) = tasks.join_next().await { |
| 139 | + if let Err(err) = res { |
| 140 | + error!(?err, "failed to join task") |
| 141 | + } |
| 142 | + } |
| 143 | + return res.context("failed to listen for ^C") |
| 144 | + } |
| 145 | + } |
| 146 | + } |
| 147 | +} |
0 commit comments