Tahinli/radioxide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: 🔧 new structure for both tls and non-tls with config files and generics

Browse source
This commit is contained in:
Ahmet Kaan GÜMÜŞ 2024-04-21 04:29:17 +03:00
parent 1350046453
commit 9e8cc84f66
11 changed files with 207 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

5
back/configs/relay_configs.txt Normal file
View file

@ -0,0 +1,5 @@
axum_address: 192.168.1.2:2323
listener_address: 192.168.1.2:2424
streamer_address: 192.168.1.2:2525
latency: 50
tls: false

9
back/src/lib.rs
View file

@ -6,6 +6,15 @@ pub mod routing;
pub mod streaming;
pub mod utils;
#[derive(Debug, Clone)]
pub struct Config {
pub axum_address: String,
pub listener_address: String,
pub streamer_address: String,
pub latency: u16,
pub tls: bool,
}
#[derive(Debug, Clone)]
pub struct AppState {}

29
back/src/main.rs
View file

@ -1,28 +1,27 @@
use axum_server::tls_rustls::RustlsConfig;
use back::{routing, streaming, AppState};
use std::{env, net::SocketAddr};
fn take_args() -> String {
let mut bind_address: String = String::new();
for element in env::args() {
bind_address = element
}
println!("\n\n\tOn Air -> http://{}\n\n", bind_address);
bind_address
}
use back::{routing, streaming, utils::get_config, AppState};
use std::net::SocketAddr;
#[tokio::main]
async fn main() {
println!("Hello, world!");
let config =
let relay_config = get_config().await;
let rustls_config =
RustlsConfig::from_pem_file("certificates/fullchain.pem", "certificates/privkey.pem")
.await
.unwrap();
let state = AppState {};
let app = routing::routing(axum::extract::State(state)).await;
let addr = SocketAddr::from(take_args().parse::<SocketAddr>().unwrap());
tokio::spawn(streaming::start());
axum_server::bind_rustls(addr, config)
let addr = SocketAddr::from(
relay_config
.axum_address
.clone()
.parse::<SocketAddr>()
.unwrap(),
);
println!("\n\n\tOn Air -> http://{}\n\n", relay_config.axum_address.clone());
tokio::spawn(streaming::start(relay_config));
axum_server::bind_rustls(addr, rustls_config)
.serve(app.into_make_service())
.await
.unwrap();

3
back/src/routing.rs
View file

@ -1,4 +1,4 @@
use crate::{streaming, AppState, CoinStatus, ServerStatus};
use crate::{AppState, CoinStatus, ServerStatus};
use axum::{
body::Body, extract::State, http::StatusCode, response::IntoResponse, routing::get, Json,
Router,
@ -42,7 +42,6 @@ async fn flip_coin() -> impl IntoResponse {
#[axum::debug_handler]
async fn stream() -> impl IntoResponse {
println!("Stream");
streaming::start().await;
let file = File::open("audios/audio.mp3").await.unwrap();
let stream = ReaderStream::new(file);
Body::from_stream(stream)

138
back/src/streaming.rs
View file

@ -9,26 +9,29 @@ use futures_util::{SinkExt, StreamExt};
use rustls_pemfile::{certs, pkcs8_private_keys};
use tokio::{
net::{TcpListener, TcpStream},
net::TcpListener,
sync::broadcast::{channel, Receiver, Sender},
time::Instant,
};
use tokio_rustls::{
rustls::pki_types::{CertificateDer, PrivateKeyDer},
server::TlsStream,
TlsAcceptor,
};
use tokio_tungstenite::{tungstenite::Message, WebSocketStream};
use tokio_tungstenite::tungstenite::{Error, Message};
use crate::{Listener, Streamer};
use crate::{Config, Listener, Streamer};
const BUFFER_LENGTH: usize = 1000000;
const MAX_TOLERATED_MESSAGE_COUNT: usize = 10;
pub async fn start() {
pub async fn start(relay_configs: Config) {
//need to move them for multi streamer
let socket = TcpListener::bind("192.168.1.2:2424").await.unwrap();
let listener_socket = TcpListener::bind(relay_configs.listener_address)
.await
.unwrap();
let (record_producer, record_consumer) = channel(BUFFER_LENGTH);
let streamer_socket = TcpListener::bind("192.168.1.2:2525").await.unwrap();
let streamer_socket = TcpListener::bind(relay_configs.streamer_address)
.await
.unwrap();
let timer = Instant::now();
let fullchain: io::Result<Vec<CertificateDer<'static>>> = certs(&mut BufReader::new(
@ -44,35 +47,50 @@ pub async fn start() {
.map(Into::into);
let privkey = privkey.unwrap();
let config = tokio_rustls::rustls::ServerConfig::builder()
let server_tls_config = tokio_rustls::rustls::ServerConfig::builder()
.with_no_client_auth()
.with_single_cert(fullchain, privkey)
.unwrap();
let acceptor = TlsAcceptor::from(Arc::new(config));
let acceptor = TlsAcceptor::from(Arc::new(server_tls_config));
loop {
match streamer_socket.accept().await {
Ok((streamer_tcp, streamer_info)) => {
let streamer_tcp_tls = acceptor.accept(streamer_tcp).await.unwrap();
match tokio_tungstenite::accept_async(streamer_tcp_tls).await {
Ok(ws_stream) => {
println!(
"New Streamer: {:#?} | {:#?}",
streamer_info,
timer.elapsed()
);
let new_streamer = Streamer {
ip: streamer_info.ip(),
port: streamer_info.port(),
};
tokio::spawn(streamer_stream(
new_streamer,
record_producer,
ws_stream,
timer,
));
break;
let new_streamer = Streamer {
ip: streamer_info.ip(),
port: streamer_info.port(),
};
println!(
"New Streamer: {:#?} | {:#?}",
streamer_info,
timer.elapsed()
);
if relay_configs.tls {
let streamer_tcp_tls = acceptor.accept(streamer_tcp).await.unwrap();
match tokio_tungstenite::accept_async(streamer_tcp_tls).await {
Ok(ws_stream) => {
tokio::spawn(streamer_stream(
new_streamer,
record_producer,
ws_stream,
timer,
));
break;
}
Err(err_val) => eprintln!("Error: TCP to WS Transform | {}", err_val),
}
} else {
match tokio_tungstenite::accept_async(streamer_tcp).await {
Ok(ws_stream) => {
tokio::spawn(streamer_stream(
new_streamer,
record_producer,
ws_stream,
timer,
));
break;
}
Err(err_val) => eprintln!("Error: TCP to WS Transform | {}", err_val),
}
Err(err_val) => eprintln!("Error: TCP to WS Transform | {}", err_val),
}
}
Err(err_val) => eprintln!("Error: TCP Accept Connection | {}", err_val),
@ -80,22 +98,41 @@ pub async fn start() {
}
let (message_producer, message_consumer) = channel(BUFFER_LENGTH);
let (buffered_producer, _) = channel(BUFFER_LENGTH);
tokio::spawn(message_organizer(message_producer.clone(), record_consumer));
tokio::spawn(buffer_layer(message_consumer, buffered_producer.clone()));
tokio::spawn(message_organizer(
message_producer.clone(),
record_consumer,
relay_configs.latency,
));
tokio::spawn(buffer_layer(
message_consumer,
buffered_producer.clone(),
relay_configs.latency,
));
tokio::spawn(status_checker(buffered_producer.clone(), timer));
while let Ok((tcp_stream, listener_info)) = socket.accept().await {
let streamer_tcp_tls = acceptor.accept(tcp_stream).await.unwrap();
let ws_stream = tokio_tungstenite::accept_async(streamer_tcp_tls).await.unwrap();
println!("New Listener: {} | {:#?}", listener_info, timer.elapsed());
while let Ok((tcp_stream, listener_info)) = listener_socket.accept().await {
let new_listener = Listener {
ip: listener_info.ip(),
port: listener_info.port(),
};
tokio::spawn(stream(
new_listener,
ws_stream,
buffered_producer.subscribe(),
));
if relay_configs.tls {
let streamer_tcp_tls = acceptor.accept(tcp_stream).await.unwrap();
let wss_stream = tokio_tungstenite::accept_async(streamer_tcp_tls)
.await
.unwrap();
tokio::spawn(stream(
new_listener,
wss_stream,
buffered_producer.subscribe(),
));
} else {
let ws_stream = tokio_tungstenite::accept_async(tcp_stream).await.unwrap();
tokio::spawn(stream(
new_listener,
ws_stream,
buffered_producer.subscribe(),
));
}
println!("New Listener: {} | {:#?}", listener_info, timer.elapsed());
}
}
async fn status_checker(buffered_producer: Sender<Message>, timer: Instant) {
@ -124,9 +161,13 @@ async fn status_checker(buffered_producer: Sender<Message>, timer: Instant) {
}
}
}
async fn buffer_layer(mut message_consumer: Receiver<Message>, buffered_producer: Sender<Message>) {
async fn buffer_layer(
mut message_consumer: Receiver<Message>,
buffered_producer: Sender<Message>,
delay: u16,
) {
loop {
tokio::time::sleep(Duration::from_millis(50)).await;
tokio::time::sleep(Duration::from_millis(delay.into())).await;
while message_consumer.len() > 0 {
match message_consumer.recv().await {
Ok(message) => match buffered_producer.send(message) {
@ -138,10 +179,12 @@ async fn buffer_layer(mut message_consumer: Receiver<Message>, buffered_producer
}
}
}
async fn streamer_stream(
async fn streamer_stream<
T: futures_util::Stream<Item = Result<Message, Error>> + std::marker::Unpin,
>(
streamer: Streamer,
record_producer: Sender<Message>,
mut ws_stream: WebSocketStream<TlsStream<TcpStream>>,
mut ws_stream: T,
timer: Instant,
) {
loop {
@ -173,6 +216,7 @@ async fn streamer_stream(
async fn message_organizer(
message_producer: Sender<Message>,
mut record_consumer: Receiver<Message>,
delay: u16,
) {
loop {
match record_consumer.recv().await {
@ -182,12 +226,12 @@ async fn message_organizer(
},
Err(_) => {}
}
tokio::time::sleep(Duration::from_millis(50)).await;
tokio::time::sleep(Duration::from_millis(delay.into())).await;
}
}
async fn stream(
async fn stream<T: futures_util::Sink<Message> + std::marker::Unpin>(
listener: Listener,
mut ws_stream: WebSocketStream<TlsStream<TcpStream>>,
mut ws_stream: T,
mut buffered_consumer: Receiver<Message>,
) {
while let Ok(message) = buffered_consumer.recv().await {

26
back/src/utils.rs
View file

@ -1 +1,27 @@
use tokio::{fs::File, io::AsyncReadExt};
use crate::Config;
pub async fn get_config() -> Config {
let mut config_file = File::open("configs/relay_configs.txt").await.unwrap();
let mut configs_unparsed = String::new();
config_file
.read_to_string(&mut configs_unparsed)
.await
.unwrap();
let configs_parsed: Vec<&str> = configs_unparsed.split_terminator("\n").collect();
let mut configs_cleaned: Vec<&str> = vec![];
for config in configs_parsed {
let dirty_configs: Vec<&str> = config.split(": ").collect();
configs_cleaned.push(dirty_configs[1]);
}
Config {
axum_address: configs_cleaned[0].to_string(),
listener_address: configs_cleaned[1].to_string(),
streamer_address: configs_cleaned[2].to_string(),
latency: configs_cleaned[3].parse().unwrap(),
tls: configs_cleaned[4].parse().unwrap(),
}
}

5
streamer/configs/streamer_configs.txt
View file

@ -1,3 +1,4 @@
address: tahinli.com.tr:2525
address: 192.168.1.2:2525
quality: 6
latency: 100
latency: 100
tls: false

1
streamer/src/lib.rs
View file

@ -1,5 +1,6 @@
pub mod recording;
pub mod streaming;
pub mod utils;
pub const BUFFER_LENGTH: usize = 1000000;

24
streamer/src/main.rs
View file

@ -1,7 +1,7 @@
use std::time::Duration;
use streamer::{recording::recording, streaming::start, Config, BUFFER_LENGTH};
use tokio::{fs::File, io::AsyncReadExt, sync::broadcast::channel};
use streamer::{recording::recording, streaming::start, utils::get_config, BUFFER_LENGTH};
use tokio::sync::broadcast::channel;
#[tokio::main]
async fn main() {
@ -14,23 +14,3 @@ async fn main() {
tokio::time::sleep(Duration::from_secs(1000000000)).await;
}
}
async fn get_config() -> Config {
let mut config_file = File::open("configs/streamer_configs.txt").await.unwrap();
let mut configs_unparsed = String::new();
config_file.read_to_string(&mut configs_unparsed).await.unwrap();
let configs_parsed:Vec<&str> = configs_unparsed.split_terminator("\n").collect();
let mut configs_cleaned: Vec<&str> = vec![];
for config in configs_parsed {
let dirty_configs: Vec<&str> = config.split(": ").collect();
configs_cleaned.push(dirty_configs[1]);
}
Config {
address: configs_cleaned[0].to_string(),
quality: configs_cleaned[1].parse().unwrap(),
latency: configs_cleaned[2].parse().unwrap(),
tls: configs_cleaned[3].parse().unwrap(),
}
}

47
streamer/src/streaming.rs
View file

@ -4,38 +4,55 @@ use brotli::CompressorWriter;
use futures_util::SinkExt;
use ringbuf::HeapRb;
use tokio::sync::broadcast::{channel, Receiver, Sender};
use tokio_tungstenite::{tungstenite::Message, WebSocketStream};
use tokio_tungstenite::tungstenite::Message;
use crate::BUFFER_LENGTH;
use crate::{Config, BUFFER_LENGTH};
const MAX_TOLERATED_MESSAGE_COUNT: usize = 10;
pub async fn start(sound_stream_consumer: Receiver<f32>) {
let connect_addr = "wss://tahinli.com.tr:2525";
let tls_client_config = rustls_platform_verifier::tls_config();
let tls_connector = tokio_tungstenite::Connector::Rustls(Arc::new(tls_client_config));
pub async fn start(sound_stream_consumer: Receiver<f32>, streamer_config:Config) {
let connect_addr =
match streamer_config.tls {
true => format!("wss://{}", streamer_config.address),
false => format!("ws://{}", streamer_config.address),
};
let ws_stream;
match streamer_config.tls {
true => {
let tls_client_config = rustls_platform_verifier::tls_config();
let tls_connector = tokio_tungstenite::Connector::Rustls(Arc::new(tls_client_config));
match tokio_tungstenite::connect_async_tls_with_config(
connect_addr,
connect_addr.clone(),
None,
false,
Some(tls_connector),
)
.await
{
Ok(ws_stream_connected) => ws_stream = ws_stream_connected.0,
Ok(wss_stream_connected) => ws_stream = wss_stream_connected.0,
Err(_) => {
return;
}
}
},
false => {
match tokio_tungstenite::connect_async(connect_addr.clone()).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(message_organizer(message_producer, sound_stream_consumer, streamer_config.quality, streamer_config.latency));
tokio::spawn(stream(ws_stream, message_consumer));
}
async fn message_organizer(message_producer: Sender<Message>, mut consumer: Receiver<f32>) {
async fn message_organizer(message_producer: Sender<Message>, mut consumer: Receiver<f32>, quality: u8, latency:u16) {
loop {
let mut messages: Vec<u8> = Vec::new();
let mut iteration = consumer.len();
@ -53,7 +70,7 @@ async fn message_organizer(message_producer: Sender<Message>, mut consumer: Rece
let _zero = charred.remove(1);
let _point = charred.remove(1);
}
charred.truncate(4);
charred.truncate(quality.into());
let mut single_data_packet: Vec<u8> = vec![];
for char in charred {
let char_packet = char.to_string().as_bytes().to_vec();
@ -89,12 +106,12 @@ async fn message_organizer(message_producer: Sender<Message>, mut consumer: Rece
// message_producer.receiver_count()
// );
}
tokio::time::sleep(Duration::from_millis(100)).await;
tokio::time::sleep(Duration::from_millis(latency.into())).await;
}
}
async fn stream(
mut ws_stream: WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>,
async fn stream <T: futures_util::Sink<Message> + std::marker::Unpin>(
mut ws_stream: T,
mut message_consumer: Receiver<Message>,
) {
while let Ok(message) = message_consumer.recv().await {

23
streamer/src/utils.rs Normal file
View file

@ -0,0 +1,23 @@
use tokio::{fs::File, io::AsyncReadExt};
use crate::Config;
pub async fn get_config() -> Config {
let mut config_file = File::open("configs/streamer_configs.txt").await.unwrap();
let mut configs_unparsed = String::new();
config_file.read_to_string(&mut configs_unparsed).await.unwrap();
let configs_parsed:Vec<&str> = configs_unparsed.split_terminator("\n").collect();
let mut configs_cleaned: Vec<&str> = vec![];
for config in configs_parsed {
let dirty_configs: Vec<&str> = config.split(": ").collect();
configs_cleaned.push(dirty_configs[1]);
}
Config {
address: configs_cleaned[0].to_string(),
quality: configs_cleaned[1].parse().unwrap(),
latency: configs_cleaned[2].parse().unwrap(),
tls: configs_cleaned[3].parse().unwrap(),
}
}