chore: checkpoint before Python removal

vendor/tungstenite/examples/autobahn-client.rs

@@ -0,0 +1,49 @@
+use log::*;
+
+use tungstenite::{connect, Error, Message, Result};
+
+const AGENT: &str = "Tungstenite";
+
+fn get_case_count() -> Result<u32> {
+    let (mut socket, _) = connect("ws://localhost:9001/getCaseCount")?;
+    let msg = socket.read()?;
+    socket.close(None)?;
+    Ok(msg.into_text()?.as_str().parse::<u32>().unwrap())
+}
+
+fn update_reports() -> Result<()> {
+    let (mut socket, _) = connect(format!("ws://localhost:9001/updateReports?agent={AGENT}"))?;
+    socket.close(None)?;
+    Ok(())
+}
+
+fn run_test(case: u32) -> Result<()> {
+    info!("Running test case {}", case);
+    let case_url = format!("ws://localhost:9001/runCase?case={case}&agent={AGENT}");
+    let (mut socket, _) = connect(case_url)?;
+    loop {
+        match socket.read()? {
+            msg @ Message::Text(_) | msg @ Message::Binary(_) => {
+                socket.send(msg)?;
+            }
+            Message::Ping(_) | Message::Pong(_) | Message::Close(_) | Message::Frame(_) => {}
+        }
+    }
+}
+
+fn main() {
+    env_logger::init();
+
+    let total = get_case_count().unwrap();
+
+    for case in 1..=total {
+        if let Err(e) = run_test(case) {
+            match e {
+                Error::ConnectionClosed | Error::Protocol(_) | Error::Utf8 => (),
+                err => error!("test: {}", err),
+            }
+        }
+    }
+
+    update_reports().unwrap();
+}

vendor/tungstenite/examples/autobahn-server.rs

@@ -0,0 +1,47 @@
+use std::{
+    net::{TcpListener, TcpStream},
+    thread::spawn,
+};
+
+use log::*;
+use tungstenite::{accept, handshake::HandshakeRole, Error, HandshakeError, Message, Result};
+
+fn must_not_block<Role: HandshakeRole>(err: HandshakeError<Role>) -> Error {
+    match err {
+        HandshakeError::Interrupted(_) => panic!("Bug: blocking socket would block"),
+        HandshakeError::Failure(f) => f,
+    }
+}
+
+fn handle_client(stream: TcpStream) -> Result<()> {
+    let mut socket = accept(stream).map_err(must_not_block)?;
+    info!("Running test");
+    loop {
+        match socket.read()? {
+            msg @ Message::Text(_) | msg @ Message::Binary(_) => {
+                socket.send(msg)?;
+            }
+            Message::Ping(_) | Message::Pong(_) | Message::Close(_) | Message::Frame(_) => {}
+        }
+    }
+}
+
+fn main() {
+    env_logger::init();
+
+    let server = TcpListener::bind("127.0.0.1:9002").unwrap();
+
+    for stream in server.incoming() {
+        spawn(move || match stream {
+            Ok(stream) => {
+                if let Err(err) = handle_client(stream) {
+                    match err {
+                        Error::ConnectionClosed | Error::Protocol(_) | Error::Utf8 => (),
+                        e => error!("test: {}", e),
+                    }
+                }
+            }
+            Err(e) => error!("Error accepting stream: {}", e),
+        });
+    }
+}

vendor/tungstenite/examples/callback-error.rs

@@ -0,0 +1,23 @@
+use std::{net::TcpListener, thread::spawn};
+
+use tungstenite::{
+    accept_hdr,
+    handshake::server::{Request, Response},
+    http::StatusCode,
+};
+
+fn main() {
+    let server = TcpListener::bind("127.0.0.1:3012").unwrap();
+    for stream in server.incoming() {
+        spawn(move || {
+            let callback = |_req: &Request, _resp| {
+                let resp = Response::builder()
+                    .status(StatusCode::FORBIDDEN)
+                    .body(Some("Access denied".into()))
+                    .unwrap();
+                Err(resp)
+            };
+            accept_hdr(stream.unwrap(), callback).unwrap_err();
+        });
+    }
+}

vendor/tungstenite/examples/client.rs

@@ -0,0 +1,21 @@
+use tungstenite::{connect, Message};
+
+fn main() {
+    env_logger::init();
+
+    let (mut socket, response) = connect("ws://localhost:3012/socket").expect("Can't connect");
+
+    println!("Connected to the server");
+    println!("Response HTTP code: {}", response.status());
+    println!("Response contains the following headers:");
+    for (header, _value) in response.headers() {
+        println!("* {header}");
+    }
+
+    socket.send(Message::Text("Hello WebSocket".into())).unwrap();
+    loop {
+        let msg = socket.read().expect("Error reading message");
+        println!("Received: {msg}");
+    }
+    // socket.close(None);
+}

vendor/tungstenite/examples/server.rs

@@ -0,0 +1,38 @@
+use std::{net::TcpListener, thread::spawn};
+
+use tungstenite::{
+    accept_hdr,
+    handshake::server::{Request, Response},
+};
+
+fn main() {
+    env_logger::init();
+    let server = TcpListener::bind("127.0.0.1:3012").unwrap();
+    for stream in server.incoming() {
+        spawn(move || {
+            let callback = |req: &Request, mut response: Response| {
+                println!("Received a new ws handshake");
+                println!("The request's path is: {}", req.uri().path());
+                println!("The request's headers are:");
+                for (header, _value) in req.headers() {
+                    println!("* {header}");
+                }
+
+                // Let's add an additional header to our response to the client.
+                let headers = response.headers_mut();
+                headers.append("MyCustomHeader", ":)".parse().unwrap());
+                headers.append("SOME_TUNGSTENITE_HEADER", "header_value".parse().unwrap());
+
+                Ok(response)
+            };
+            let mut websocket = accept_hdr(stream.unwrap(), callback).unwrap();
+
+            loop {
+                let msg = websocket.read().unwrap();
+                if msg.is_binary() || msg.is_text() {
+                    websocket.send(msg).unwrap();
+                }
+            }
+        });
+    }
+}

vendor/tungstenite/examples/srv_accept_unmasked_frames.rs

@@ -0,0 +1,48 @@
+use std::{net::TcpListener, thread::spawn};
+use tungstenite::{
+    accept_hdr_with_config,
+    handshake::server::{Request, Response},
+    protocol::WebSocketConfig,
+};
+
+fn main() {
+    env_logger::init();
+    let server = TcpListener::bind("127.0.0.1:3012").unwrap();
+    for stream in server.incoming() {
+        spawn(move || {
+            let callback = |req: &Request, mut response: Response| {
+                println!("Received a new ws handshake");
+                println!("The request's path is: {}", req.uri().path());
+                println!("The request's headers are:");
+                for (header, _value) in req.headers() {
+                    println!("* {header}");
+                }
+
+                // Let's add an additional header to our response to the client.
+                let headers = response.headers_mut();
+                headers.append("MyCustomHeader", ":)".parse().unwrap());
+                headers.append("SOME_TUNGSTENITE_HEADER", "header_value".parse().unwrap());
+
+                Ok(response)
+            };
+
+            let config = Some(
+                WebSocketConfig::default()
+                    // This setting allows to accept client frames which are not masked
+                    // This is not in compliance with RFC 6455 but might be handy in some
+                    // rare cases where it is necessary to integrate with existing/legacy
+                    // clients which are sending unmasked frames
+                    .accept_unmasked_frames(true),
+            );
+
+            let mut websocket = accept_hdr_with_config(stream.unwrap(), callback, config).unwrap();
+
+            loop {
+                let msg = websocket.read().unwrap();
+                if msg.is_binary() || msg.is_text() {
+                    println!("received message {msg}");
+                }
+            }
+        });
+    }
+}