Initial commit...it works?

src/main.rs

@@ -0,0 +1,123 @@
+use anyhow::Result;
+use std::time::Duration;
+use tokio::net::tcp::{OwnedReadHalf, OwnedWriteHalf};
+use tokio::net::TcpStream;
+use tracing::error;
+use tracing::info;
+use tracing::info_span;
+use tracing::Instrument;
+use tracing_subscriber::filter::LevelFilter;
+use tracing_subscriber::EnvFilter;
+use wtransport::endpoint::IncomingSession;
+use wtransport::Endpoint;
+use wtransport::Identity;
+use wtransport::ServerConfig;
+use tokio::io::AsyncReadExt;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    init_logging();
+
+    let config = ServerConfig::builder()
+        .with_bind_default(4433)
+        //.with_identity(&Identity::self_signed(["localhost"]).unwrap())
+        .with_identity(&Identity::load_pemfiles("cert.pem", "key.pem").await?)
+        .keep_alive_interval(Some(Duration::from_secs(3)))
+        .build();
+
+    let server = Endpoint::server(config)?;
+
+    info!("Server ready!");
+
+    for id in 0.. {
+        let incoming_session = server.accept().await;
+        tokio::spawn(handle_connection(incoming_session, id).instrument(info_span!("Connection", id)));
+    }
+
+    Ok(())
+}
+
+async fn handle_connection(incoming_session: IncomingSession, id: usize) {
+    let _result = handle_connection_impl(incoming_session, id).await;
+    //error!("{:?}", result);
+}
+
+async fn handle_connection_impl(incoming_session: IncomingSession, id: usize) -> Result<()> {
+    let mut buffer = vec![0; 65536].into_boxed_slice();
+
+    info!("Waiting for session request...");
+
+    let session_request = incoming_session.await?;
+
+    info!(
+        "New session: Authority: '{}', Path: '{}'",
+        session_request.authority(),
+        session_request.path()
+    );
+
+    let connection = session_request.accept().await?;
+    let stream = connection.accept_bi().await?;
+
+    let server_tcp = TcpStream::connect("127.0.0.1:64738").await?.into_split();
+
+    tokio::spawn(handle_client_to_server(stream.1, server_tcp.1).instrument(info_span!("Handler", "Client to server")));
+    tokio::spawn(handle_server_to_client(stream.0, server_tcp.0).instrument(info_span!("Handler", "Server to client")));
+
+    Ok(())
+}
+
+
+async fn handle_client_to_server(
+    client_stream: wtransport::RecvStream,
+    server_stream: OwnedWriteHalf,
+) {
+    let result = client_to_server_loop(client_stream, server_stream).await;
+    error!("{:?}", result);
+}
+
+async fn client_to_server_loop(
+    mut client_stream: wtransport::RecvStream,
+    server_stream: OwnedWriteHalf,
+) -> Result<()> {
+    let mut buffer = vec![0; 65536].into_boxed_slice();
+    loop {
+        let _bytes_read = match client_stream.read(&mut buffer).await? {
+            Some(bytes_read) => bytes_read,
+            None => continue,
+        };
+
+        server_stream.try_write(&buffer)?;
+    }
+}
+
+async fn handle_server_to_client(
+    client_stream: wtransport::SendStream,
+    server_stream: OwnedReadHalf,
+) {
+    let result = server_to_client_loop(client_stream, server_stream).await;
+    error!("{:?}", result);
+}
+
+async fn server_to_client_loop(
+    mut client_stream: wtransport::SendStream,
+    mut server_stream: OwnedReadHalf,
+) -> Result<()> {
+    let mut buffer = vec![0; 65536].into_boxed_slice();
+    loop {
+        server_stream.read(&mut buffer).await?;
+
+        client_stream.write_all(&buffer).await?;
+    }
+}
+
+fn init_logging() {
+    let env_filter = EnvFilter::builder()
+        .with_default_directive(LevelFilter::INFO.into())
+        .from_env_lossy();
+
+    tracing_subscriber::fmt()
+        .with_target(true)
+        .with_level(true)
+        .with_env_filter(env_filter)
+        .init();
+}