daqbuf/daqbuffer
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reduce log

Browse Source
This commit is contained in:
Dominik Werder
2025-02-25 11:37:23 +01:00
parent 7eae8ed95c
commit 038e8fb38e
1 changed files with 24 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/httpret/src/http3.rs
+24 -20
View File
@@ -4,6 +4,7 @@ use h3_quinn::quinn::crypto::rustls::QuicServerConfig;
use h3_quinn::BidiStream; use h3_quinn::BidiStream;
use http::Request; use http::Request;
use http::StatusCode; use http::StatusCode;
use netpod::log;
use quinn; use quinn;
use quinn::Endpoint; use quinn::Endpoint;
use quinn::EndpointConfig; use quinn::EndpointConfig;
@@ -21,7 +22,9 @@ use taskrun::tokio;
const EARLY_DATA_MAX: u32 = u32::MAX * 0; const EARLY_DATA_MAX: u32 = u32::MAX * 0;
macro_rules! info { ($($arg:expr),*) => ( if true { netpod::log::info!($($arg),*); } ); } macro_rules! info { ($($arg:expr),*) => ( if true { log::debug!($($arg),*); } ); }
macro_rules! debug { ($($arg:expr),*) => ( if true { log::debug!($($arg),*); } ); }
#[derive(Debug)] #[derive(Debug)]
struct TicketerCustom {} struct TicketerCustom {}
@@ -66,7 +69,7 @@ pub struct Http3Support {
impl Http3Support { impl Http3Support {
pub async fn new_or_dummy(bind_addr: SocketAddr) -> Result<Self, Error> { pub async fn new_or_dummy(bind_addr: SocketAddr) -> Result<Self, Error> {
Ok(Self::new(bind_addr).await.unwrap_or_else(|e| { Ok(Self::new(bind_addr).await.unwrap_or_else(|e| {
info!("error {}", e); debug!("error {}", e);
Self::dummy() Self::dummy()
})) }))
} }
@@ -79,10 +82,10 @@ impl Http3Support {
let key = PemObject::from_pem_file("key.pem")?; let key = PemObject::from_pem_file("key.pem")?;
let cert = PemObject::from_pem_file("cert.pem")?; let cert = PemObject::from_pem_file("cert.pem")?;
let mut provider = rustls::crypto::ring::default_provider(); let mut provider = rustls::crypto::ring::default_provider();
info!("provider default {:?}", provider); debug!("provider default {:?}", provider);
provider.cipher_suites = rustls::crypto::ring::ALL_CIPHER_SUITES.to_vec(); provider.cipher_suites = rustls::crypto::ring::ALL_CIPHER_SUITES.to_vec();
provider.kx_groups = rustls::crypto::ring::ALL_KX_GROUPS.to_vec(); provider.kx_groups = rustls::crypto::ring::ALL_KX_GROUPS.to_vec();
info!("provider custom {:?}", provider); debug!("provider custom {:?}", provider);
provider.install_default().map_err(|_| Error::RingInstallDefault)?; provider.install_default().map_err(|_| Error::RingInstallDefault)?;
let mut tls_conf = rustls::ServerConfig::builder() let mut tls_conf = rustls::ServerConfig::builder()
.with_no_client_auth() .with_no_client_auth()
@@ -122,7 +125,7 @@ impl Http3Support {
let quic_conf = Arc::new(v); let quic_conf = Arc::new(v);
let conf_srv = quinn::ServerConfig::with_crypto(quic_conf); let conf_srv = quinn::ServerConfig::with_crypto(quic_conf);
let sock = std::net::UdpSocket::bind(bind_addr)?; let sock = std::net::UdpSocket::bind(bind_addr)?;
info!("h3 sock {:?}", sock); debug!("h3 sock {:?}", sock);
let rt = quinn::default_runtime().ok_or_else(|| Error::NoRuntime)?; let rt = quinn::default_runtime().ok_or_else(|| Error::NoRuntime)?;
let ep1 = Endpoint::new(conf, Some(conf_srv.clone()), sock, rt)?; let ep1 = Endpoint::new(conf, Some(conf_srv.clone()), sock, rt)?;
tokio::task::spawn(Self::accept(ep1.clone())); tokio::task::spawn(Self::accept(ep1.clone()));
@@ -138,32 +141,33 @@ impl Http3Support {
} }
async fn accept(ep: Endpoint) { async fn accept(ep: Endpoint) {
info!("accepting h3"); debug!("accepting h3");
while let Some(inc) = ep.accept().await { while let Some(inc) = ep.accept().await {
let addr_remote = inc.remote_address(); let addr_remote = inc.remote_address();
tokio::spawn(Self::handle_incoming(inc, addr_remote)); tokio::spawn(Self::handle_incoming(inc, addr_remote));
} }
debug!("accepting h3 RETURN");
} }
async fn handle_incoming(inc: Incoming, addr_remote: SocketAddr) -> Result<(), Error> { async fn handle_incoming(inc: Incoming, addr_remote: SocketAddr) -> Result<(), Error> {
info!("handle_incoming {}", addr_remote); debug!("handle_incoming {}", addr_remote);
match Self::handle_incoming_inner_2(inc, addr_remote).await { match Self::handle_incoming_inner_2(inc, addr_remote).await {
Ok(x) => Ok(x), Ok(x) => Ok(x),
Err(e) => { Err(e) => {
info!("handle_incoming_inner_2 returns error {}", e); debug!("handle_incoming_inner_2 returns error {}", e);
Err(e) Err(e)
} }
} }
} }
async fn handle_incoming_inner_1(inc: Incoming, addr_remote: SocketAddr) -> Result<(), Error> { async fn handle_incoming_inner_1(inc: Incoming, addr_remote: SocketAddr) -> Result<(), Error> {
info!("handle_incoming_inner_1 new incoming {:?}", addr_remote); debug!("handle_incoming_inner_1 new incoming {:?}", addr_remote);
let conn1 = inc.accept()?.await?; let conn1 = inc.accept()?.await?;
let conn2 = h3_quinn::Connection::new(conn1); let conn2 = h3_quinn::Connection::new(conn1);
let mut conn3 = h3::server::builder().build::<_, Bytes>(conn2).await?; let mut conn3 = h3::server::builder().build::<_, Bytes>(conn2).await?;
while let Some((req, mut stream)) = conn3.accept().await? { while let Some((req, mut stream)) = conn3.accept().await? {
let (head, _body) = req.into_parts(); let (head, _body) = req.into_parts();
info!( debug!(
"see request {} {:?} {:?} {:?}", "see request {} {:?} {:?} {:?}",
addr_remote, head.method, head.uri, head.headers addr_remote, head.method, head.uri, head.headers
); );
@@ -175,35 +179,35 @@ impl Http3Support {
stream.send_response(res).await?; stream.send_response(res).await?;
stream.send_data(Bytes::from_static(b"2025-02-05T16:37:12Z")).await?; stream.send_data(Bytes::from_static(b"2025-02-05T16:37:12Z")).await?;
stream.finish().await?; stream.finish().await?;
info!("response sent {}", addr_remote); debug!("response sent {}", addr_remote);
} }
Ok(()) Ok(())
} }
async fn handle_incoming_inner_2(inc: Incoming, addr_remote: SocketAddr) -> Result<(), Error> { async fn handle_incoming_inner_2(inc: Incoming, addr_remote: SocketAddr) -> Result<(), Error> {
let selfname = "handle_incoming_inner_2"; let selfname = "handle_incoming_inner_2";
info!("{} new incoming {:?}", selfname, addr_remote); debug!("{} new incoming {:?}", selfname, addr_remote);
let conn1 = inc.await?; let conn1 = inc.await?;
info!("{} connected {:?}", selfname, addr_remote); debug!("{} connected {:?}", selfname, addr_remote);
let conn2 = h3_quinn::Connection::new(conn1); let conn2 = h3_quinn::Connection::new(conn1);
let mut conn3 = h3::server::Connection::new(conn2).await?; let mut conn3 = h3::server::Connection::new(conn2).await?;
info!("{} h3 Connection awaited {:?}", selfname, addr_remote); debug!("{} h3 Connection awaited {:?}", selfname, addr_remote);
// let mut conn3 = h3::server::builder().build::<_, Bytes>(conn2).await?; // let mut conn3 = h3::server::builder().build::<_, Bytes>(conn2).await?;
loop { loop {
break match conn3.accept().await { break match conn3.accept().await {
Ok(Some((req, stream))) => { Ok(Some((req, stream))) => {
info!("in h3 loop req {:?}", req); debug!("in h3 loop req {:?}", req);
tokio::spawn(async move { tokio::spawn(async move {
let x = Self::handle_req(req, stream, addr_remote).await; let x = Self::handle_req(req, stream, addr_remote).await;
info!("handle_req return {:?}", x); debug!("handle_req return {:?}", x);
}); });
continue; continue;
} }
Ok(None) => { Ok(None) => {
info!("in h3 loop None"); debug!("in h3 loop None");
} }
Err(e) => { Err(e) => {
info!("in h3 loop error {}", e); debug!("in h3 loop error {}", e);
} }
}; };
} }
@@ -218,7 +222,7 @@ impl Http3Support {
let method = req.method(); let method = req.method();
let uri = req.uri(); let uri = req.uri();
let headers = req.headers(); let headers = req.headers();
info!("see request {} {:?} {:?} {:?}", addr_remote, method, uri, headers); debug!("see request {} {:?} {:?} {:?}", addr_remote, method, uri, headers);
let res = http::Response::builder() let res = http::Response::builder()
// .version(http::Version::HTTP_3) // .version(http::Version::HTTP_3)
.status(StatusCode::OK) .status(StatusCode::OK)
@@ -227,7 +231,7 @@ impl Http3Support {
stream.send_response(res).await?; stream.send_response(res).await?;
// stream.send_data(Bytes::from_static(b"2025-02-05T16:37:12Z")).await?; // stream.send_data(Bytes::from_static(b"2025-02-05T16:37:12Z")).await?;
// stream.finish().await?; // stream.finish().await?;
info!("response sent {}", addr_remote); debug!("response sent {}", addr_remote);
Ok(()) Ok(())
} }
} }