init

src/main.rs

@@ -0,0 +1,64 @@
+use std::time::Duration;
+
+use futures_util::{SinkExt, StreamExt};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::{TcpListener, TcpStream},
+    spawn,
+    time::sleep,
+};
+use tokio_tungstenite::tungstenite::Message;
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let addr = std::env::var("TCPWS_ADDR").expect("expected env var TCPWS_ADDR");
+    let listener =
+        TcpListener::bind(std::env::var("TCPWS_BIND").expect("expected env var TCPWS_BIND"))
+            .await
+            .unwrap();
+    loop {
+        if let Ok((ws, _)) = listener.accept().await {
+            if let Ok(con) = TcpStream::connect(&addr).await {
+                spawn(async move {
+                    let (mut con_rx, mut con_tx) = con.into_split();
+                    let ws = tokio_tungstenite::accept_async(ws).await.unwrap();
+                    let (mut ws_tx, mut ws_rx) = ws.split();
+                    spawn(async move {
+                        loop {
+                            match ws_rx.next().await {
+                                Some(Ok(Message::Binary(data))) => {
+                                    con_tx.write_all(&data).await.unwrap();
+                                }
+                                Some(Ok(Message::Text(data))) => {
+                                    con_tx.write_all(data.as_bytes()).await.unwrap();
+                                }
+                                Some(Ok(
+                                    Message::Ping(_) | Message::Pong(_) | Message::Frame(_),
+                                )) => {}
+                                None | Some(Err(_)) | Some(Ok(Message::Close(_))) => {
+                                    con_tx.shutdown().await.ok();
+                                    break;
+                                }
+                            }
+                        }
+                    });
+                    let mut buf = [0u8; 256];
+                    loop {
+                        match con_rx.read(&mut buf).await {
+                            Err(_) | Ok(0) => {
+                                ws_tx.close().await.ok();
+                                break;
+                            }
+                            Ok(n) => ws_tx
+                                .send(Message::binary(buf[0..n].to_vec()))
+                                .await
+                                .unwrap(),
+                        }
+                    }
+                });
+            }
+        } else {
+            sleep(Duration::from_millis(100)).await;
+        }
+    }
+}