refactor: ♻️ refactor ring with channel

This commit is contained in:
Ahmet Kaan GÜMÜŞ 2024-04-09 02:20:24 +03:00
parent 7707c66407
commit e26b0b9fd1
3 changed files with 42 additions and 41 deletions

View file

@ -6,13 +6,14 @@ pub mod routing;
pub mod streaming; pub mod streaming;
pub mod utils; pub mod utils;
#[derive(Debug, Clone)]
pub struct AppState {}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Listener { pub struct Listener {
ip: IpAddr, ip: IpAddr,
port: u16, port: u16,
} }
#[derive(Debug, Clone)]
pub struct AppState {}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
enum ServerStatus { enum ServerStatus {
Alive, Alive,

View file

@ -1,28 +1,27 @@
use std::{mem::MaybeUninit, sync::Arc, time::Duration}; use std::time::Duration;
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use futures_util::SinkExt; use futures_util::SinkExt;
use ringbuf::{Consumer, HeapRb, Producer, SharedRb}; use ringbuf::HeapRb;
use tokio::{ use tokio::{
net::{TcpListener, TcpStream}, net::{TcpListener, TcpStream},
sync::broadcast::{channel, Receiver, Sender}, sync::broadcast::{channel, Receiver, Sender},
time::Instant,
}; };
use tokio_tungstenite::{tungstenite::Message, WebSocketStream}; use tokio_tungstenite::{tungstenite::Message, WebSocketStream};
use crate::Listener; use crate::Listener;
const BUFFER_LENGTH: usize = 1000000; const BUFFER_LENGTH: usize = 1000000;
const MAX_TOLERATED_MESSAGE_COUNT:usize = 10; const MAX_TOLERATED_MESSAGE_COUNT: usize = 10;
pub async fn start() { pub async fn start() {
let socket = TcpListener::bind("192.168.1.2:2424").await.unwrap(); let socket = TcpListener::bind("192.168.1.2:2424").await.unwrap();
println!("Dude Someone Triggered"); println!("Dude Someone Triggered");
let ring = HeapRb::<f32>::new(BUFFER_LENGTH);
let (producer, consumer) = ring.split(); let (record_producer, record_consumer) = channel(BUFFER_LENGTH);
let timer = Instant::now();
let (message_producer, _) = channel(BUFFER_LENGTH); let (message_producer, _) = channel(BUFFER_LENGTH);
tokio::spawn(record(producer)); tokio::spawn(record(record_producer));
tokio::spawn(parent_stream(timer, message_producer.clone(), consumer)); tokio::spawn(message_organizer(message_producer.clone(), record_consumer));
while let Ok((tcp_stream, info)) = socket.accept().await { while let Ok((tcp_stream, info)) = socket.accept().await {
let ws_stream = tokio_tungstenite::accept_async(tcp_stream).await.unwrap(); let ws_stream = tokio_tungstenite::accept_async(tcp_stream).await.unwrap();
println!("New Connection: {}", info); println!("New Connection: {}", info);
@ -37,18 +36,15 @@ pub async fn start() {
)); ));
} }
} }
pub async fn parent_stream( async fn message_organizer(message_producer: Sender<Message>, mut consumer: Receiver<f32>) {
timer: Instant,
message_producer: Sender<Message>,
mut consumer: Consumer<f32, Arc<SharedRb<f32, Vec<MaybeUninit<f32>>>>>,
) {
loop { loop {
let mut single_message: Vec<u8> = Vec::new(); let mut single_message: Vec<u8> = Vec::new();
let now = timer.elapsed().as_secs(); let mut iteration = consumer.len();
while !consumer.is_empty() && (timer.elapsed().as_secs() + 5) > now { while iteration > 0 {
match consumer.pop() { iteration -= 1;
Some(single_data) => { match consumer.recv().await {
let ring = HeapRb::<u8>::new(1000000); Ok(single_data) => {
let ring = HeapRb::<u8>::new(BUFFER_LENGTH);
let (mut producer, mut consumer) = ring.split(); let (mut producer, mut consumer) = ring.split();
let single_data_packet = single_data.to_string().as_bytes().to_vec(); let single_data_packet = single_data.to_string().as_bytes().to_vec();
let terminator = "#".as_bytes().to_vec(); let terminator = "#".as_bytes().to_vec();
@ -63,22 +59,24 @@ pub async fn parent_stream(
single_message.push(consumer.pop().unwrap()); single_message.push(consumer.pop().unwrap());
} }
} }
None => {} Err(_) => {}
} }
} }
match message_producer.send(single_message.into()) { tokio::time::sleep(Duration::from_secs(2)).await;
Ok(_) => {} if !single_message.is_empty() {
Err(_) => {} match message_producer.send(single_message.into()) {
Ok(_) => {}
Err(_) => {}
}
println!(
"Message Counter = {} | Receiver Count = {}",
message_producer.len(),
message_producer.receiver_count()
);
} }
println!(
"Message Len = {} | Receiver Count = {}",
message_producer.len(),
message_producer.receiver_count()
);
tokio::time::sleep(Duration::from_secs(1)).await;
} }
} }
pub async fn stream( async fn stream(
listener: Listener, listener: Listener,
mut ws_stream: WebSocketStream<TcpStream>, mut ws_stream: WebSocketStream<TcpStream>,
mut message_consumer: Receiver<Message>, mut message_consumer: Receiver<Message>,
@ -112,7 +110,7 @@ pub async fn stream(
} }
} }
pub async fn record(mut producer: Producer<f32, Arc<SharedRb<f32, Vec<MaybeUninit<f32>>>>>) { async fn record(producer: Sender<f32>) {
println!("Hello, world!"); println!("Hello, world!");
let host = cpal::default_host(); let host = cpal::default_host();
let input_device = host.default_input_device().unwrap(); let input_device = host.default_input_device().unwrap();
@ -123,7 +121,7 @@ pub async fn record(mut producer: Producer<f32, Arc<SharedRb<f32, Vec<MaybeUnini
let input_data_fn = move |data: &[f32], _: &cpal::InputCallbackInfo| { let input_data_fn = move |data: &[f32], _: &cpal::InputCallbackInfo| {
for &sample in data { for &sample in data {
match producer.push(sample) { match producer.send(sample) {
Ok(_) => {} Ok(_) => {}
Err(_) => {} Err(_) => {}
} }

View file

@ -5,7 +5,7 @@ use dioxus::{
prelude::spawn, prelude::spawn,
signals::{Signal, Writable}, signals::{Signal, Writable},
}; };
use futures_util::StreamExt; use futures_util::{stream::SplitStream, SinkExt, StreamExt};
use ringbuf::{Consumer, HeapRb, Producer, SharedRb}; use ringbuf::{Consumer, HeapRb, Producer, SharedRb};
use tokio_tungstenite_wasm::WebSocketStream; use tokio_tungstenite_wasm::WebSocketStream;
@ -20,9 +20,9 @@ pub async fn start_listening(
if is_listening() { if is_listening() {
log::info!("Trying Sir"); log::info!("Trying Sir");
let connect_addr = "ws://192.168.1.2:2424"; let connect_addr = "ws://192.168.1.2:2424";
let stream: WebSocketStream; let (mut stream_producer, stream_consumer);
match tokio_tungstenite_wasm::connect(connect_addr).await { match tokio_tungstenite_wasm::connect(connect_addr).await {
Ok(ws_stream) => stream = ws_stream, Ok(ws_stream) => (stream_producer, stream_consumer) = ws_stream.split(),
Err(_) => { Err(_) => {
is_listening.set(false); is_listening.set(false);
return; return;
@ -33,7 +33,7 @@ pub async fn start_listening(
let (producer, consumer) = ring.split(); let (producer, consumer) = ring.split();
spawn({ spawn({
async move { async move {
sound_stream(is_listening, stream, producer).await; sound_stream(is_listening, stream_consumer, producer).await;
is_listening.set(false); is_listening.set(false);
is_maintaining.set((false, is_maintaining().1)); is_maintaining.set((false, is_maintaining().1));
} }
@ -42,6 +42,8 @@ pub async fn start_listening(
async move { async move {
listen_podcast(is_listening, consumer).await; listen_podcast(is_listening, consumer).await;
is_listening.set(false); is_listening.set(false);
//stream_producer.send("Disconnect ME".into()).await.unwrap();
stream_producer.close().await.unwrap();
//buffer time waiting actually //buffer time waiting actually
tokio_with_wasm::tokio::time::sleep(Duration::from_secs(2)).await; tokio_with_wasm::tokio::time::sleep(Duration::from_secs(2)).await;
log::info!("{:#?}", is_maintaining()); log::info!("{:#?}", is_maintaining());
@ -54,12 +56,12 @@ pub async fn start_listening(
pub async fn sound_stream( pub async fn sound_stream(
is_listening: Signal<bool>, is_listening: Signal<bool>,
mut stream: WebSocketStream, mut stream_consumer: SplitStream<WebSocketStream>,
mut producer: Producer<f32, Arc<SharedRb<f32, Vec<MaybeUninit<f32>>>>>, mut producer: Producer<f32, Arc<SharedRb<f32, Vec<MaybeUninit<f32>>>>>,
) { ) {
log::info!("Attention! We need cables"); log::info!("Attention! We need cables");
while let Some(msg) = stream.next().await { while let Some(msg) = stream_consumer.next().await {
if is_listening() { if is_listening() {
let data = String::from_utf8(msg.unwrap().into()).unwrap(); let data = String::from_utf8(msg.unwrap().into()).unwrap();
let data_parsed: Vec<&str> = data.split("#").collect(); let data_parsed: Vec<&str> = data.split("#").collect();