feat: ✨ main server as a relay, support for streamer client

streamer/src/streaming.rs

@@ -0,0 +1,98 @@
+use std::time::Duration;
+
+use futures_util::SinkExt;
+use ringbuf::HeapRb;
+use tokio::sync::broadcast::{channel, Receiver, Sender};
+use tokio_tungstenite::{tungstenite::Message, WebSocketStream};
+
+use crate::BUFFER_LENGTH;
+const MAX_TOLERATED_MESSAGE_COUNT: usize = 10;
+
+pub async fn start(sound_stream_consumer: Receiver<f32>) {
+    let connect_addr = "ws://192.168.1.2:2525";
+    let ws_stream;
+    match tokio_tungstenite::connect_async(connect_addr).await {
+        Ok(ws_stream_connected) => ws_stream = ws_stream_connected.0,
+        Err(_) => {
+            return;
+        }
+    }
+    let (message_producer, message_consumer) = channel(BUFFER_LENGTH);
+    println!("Connected to: {}", connect_addr);
+    tokio::spawn(message_organizer(message_producer, sound_stream_consumer));
+    tokio::spawn(stream(ws_stream, message_consumer));
+}
+
+async fn message_organizer(message_producer: Sender<Message>, mut consumer: Receiver<f32>) {
+    loop {
+        let mut messages: Vec<u8> = Vec::new();
+        let mut iteration = consumer.len();
+        while iteration > 0 {
+            iteration -= 1;
+            match consumer.recv().await {
+                Ok(single_data) => {
+                    let ring = HeapRb::<u8>::new(BUFFER_LENGTH);
+                    let (mut producer, mut consumer) = ring.split();
+                    let single_data_packet = single_data.to_string().as_bytes().to_vec();
+                    let terminator = "#".as_bytes().to_vec();
+
+                    for element in single_data_packet {
+                        producer.push(element).unwrap();
+                    }
+                    for element in terminator {
+                        producer.push(element).unwrap();
+                    }
+                    while !consumer.is_empty() {
+                        messages.push(consumer.pop().unwrap());
+                    }
+                }
+                Err(_) => {}
+            }
+        }
+        tokio::time::sleep(Duration::from_secs(1)).await;
+        if !messages.is_empty() {
+            match message_producer.send(messages.into()) {
+                Ok(_) => {}
+                Err(_) => {}
+            }
+            println!(
+                "Message Counter = {} | Receiver Count = {}",
+                message_producer.len(),
+                message_producer.receiver_count()
+            );
+        }
+    }
+}
+
+async fn stream(
+    mut ws_stream: WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>,
+    mut message_consumer: Receiver<Message>,
+) {
+    while let Ok(message) = message_consumer.recv().await {
+        if message_consumer.len() > MAX_TOLERATED_MESSAGE_COUNT {
+            // println!(
+            //     "{} Forced to Disconnect | Reason -> Slow Consumer",
+            //     format!("{}:{}", listener.ip, listener.port)
+            // );
+            break;
+        }
+        match ws_stream.send(message).await {
+            Ok(_) => {
+                if let Err(_) = ws_stream.flush().await {
+                    // println!(
+                    //     "{} is Disconnected",
+                    //     format!("{}:{}", listener.ip, listener.port)
+                    // );
+                    break;
+                }
+            }
+            Err(_) => {
+                // println!(
+                //     "{} is Disconnected",
+                //     format!("{}:{}", listener.ip, listener.port)
+                // );
+                break;
+            }
+        }
+    }
+}