Should be working with a minimal README

Author: PtiBouchon

.cargo/config.toml

@@ -8,3 +8,6 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+# IntelliJ IDEA
+/.idea/

.gitignore

@@ -0,0 +1,11 @@
+[package]
+name = "jukebox_rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[workspace]
+members = [".", "jukebox_axum", "jukebox_yew", "my_youtube_extractor"]
+
+[dependencies]

Cargo.toml

@@ -1 +1,8 @@
-# jukebox_rust
+# jukebox_rust
+
+Trying to create a Jukebox using Rust (axum + yew)
+
+## Run the server
+
+Build the frontend using `trunk build` inside the jukebox_yew directory
+Then run `cargo run -p jukebox_axum`

README.md

@@ -0,0 +1,13 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# IntelliJ IDEA
+/.idea/

jukebox_axum/.gitignore

@@ -0,0 +1,19 @@
+[package]
+name = "jukebox_axum"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+my_youtube_extractor = { path = "../my_youtube_extractor" }
+serde = { version = "1.0", features = ["derive"] }
+axum = { version = "0.6", features = ["headers", "macros", "form", "query", "ws"] }
+tokio = { version = "1.0", features = ["full"] }
+futures = "0.3"
+askama = "0.11"
+serde_json = "1.0"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tower-http = { version = "0.3", features = ["full"] }
+tower = "0.4"

jukebox_axum/Cargo.toml

@@ -0,0 +1,3 @@
+# JukeboxAxum
+
+This is my version of the Jukebox CJ in Rust

jukebox_axum/README.md

@@ -0,0 +1,9 @@
+[general]
+# Directories to search for templates, relative to the crate root.
+dirs = ["templates"]
+# Unless you add a `-` in a block, whitespace characters won't be trimmed.
+whitespace = "preserve"
+
+#[[escaper]]
+#path = "" # I have no idea what to do
+#extensions = ["askama"]

jukebox_axum/askama.toml

@@ -0,0 +1,152 @@
+#![feature(let_chains)]
+#[allow(unused_imports)] // remove useless warning for developping
+
+#[allow(unused_imports)]
+mod search;
+#[allow(unused_imports)]
+mod templates;
+#[allow(unused_imports)]
+mod websocket;
+
+use crate::templates::index::IndexTemplate;
+use axum::body::{boxed, Body};
+use axum::extract::State;
+use axum::http::Response;
+use axum::http::StatusCode;
+use axum::response::Redirect;
+use axum::{
+    response::IntoResponse,
+    routing::{get, post},
+    Router, Server,
+};
+use my_youtube_extractor::youtube_info::YtVideoPageInfo;
+use std::net::SocketAddr;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::{broadcast, Mutex};
+use tower::{ServiceBuilder, ServiceExt};
+use tower_http::services::ServeDir;
+use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
+
+#[derive(Debug)]
+pub struct AppState {
+    pub list: Mutex<Vec<YtVideoPageInfo>>,
+    pub tx: broadcast::Sender<String>,
+}
+
+#[derive(Debug)]
+pub enum MusicChange {
+    NewMusic(YtVideoPageInfo),
+    RemoveMusic(YtVideoPageInfo),
+}
+
+// #[derive(Debug)]
+// pub enum MusicPlayerChange {
+//     PlayFirstMusic,
+//     FinishPlaying,
+// }
+
+#[tokio::main]
+async fn main() {
+    // Tracing
+    tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "jukebox_axum=debug,tower_http=debug".into()),
+        )
+        .with(tracing_subscriber::fmt::layer())
+        .init();
+
+    let (tx, _rx) = broadcast::channel(100);
+
+    // Channel between music player and axum web server
+    let app_state = Arc::new(AppState {
+        list: Mutex::new(vec![]),
+        tx,
+    });
+    // let (mut send_new_music, mut receive_new_music): (Sender<MusicChange>, Receiver<MusicChange>) = tokio::sync::mpsc::channel(10);
+    // let (mut send_player_update, mut receive_player_update): (Sender<MusicPlayerChange>, Receiver<MusicPlayerChange>) = tokio::sync::mpsc::channel(10);
+
+    let app_state_copy = app_state.clone();
+
+    // Music player
+    let music_player = async move {
+        let mut interval = tokio::time::interval(Duration::from_secs_f32(5.0));
+
+        loop {
+            tokio::select! {
+                _ = interval.tick() => {
+                    // tracing::debug!("20 seconds has passed");
+                    // let mut playlist = app_state_copy.list.lock().await;
+                    // if (playlist.len() > 0) {
+                    //     playlist.remove(0);
+                    // }
+                }
+            }
+        }
+    };
+
+    tokio::spawn(music_player);
+
+    // Axum web server
+    let app = Router::new()
+        .route("/", get(|| async { Redirect::permanent("/index") }))
+        // .route("/index", get(main_page))
+        .fallback_service(get(|req| async move {
+            match ServeDir::new("../jukebox_yew/dist/").oneshot(req).await {
+                Ok(res) => {
+                    let status = res.status();
+                    match status {
+                        StatusCode::NOT_FOUND => {
+                            let index_path =
+                                PathBuf::from("../jukebox_yew/dist/").join("index.html");
+                            let index_content = match tokio::fs::read_to_string(index_path).await {
+                                Ok(index_content) => index_content,
+                                Err(_) => {
+                                    return Response::builder()
+                                        .status(StatusCode::NOT_FOUND)
+                                        .body(boxed(Body::from("index file not found")))
+                                        .unwrap()
+                                }
+                            };
+
+                            Response::builder()
+                                .status(StatusCode::OK)
+                                .body(boxed(Body::from(index_content)))
+                                .unwrap()
+                        }
+                        _ => res.map(boxed),
+                    }
+                }
+                Err(err) => Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(boxed(Body::from(format!("error: {err}"))))
+                    .expect("error response"),
+            }
+        }))
+        // .route("/search", post(search::search))
+        // .route("/add_music", post(search::add_music))
+        .route("/websocket", get(websocket::websocket_handler))
+        .with_state(app_state);
+
+    let addr = SocketAddr::from_str("127.0.0.1:4000").unwrap();
+    tracing::info!("Starting server on http://{addr}/index");
+
+    Server::bind(&addr)
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
+}
+
+async fn main_page(State(app_state): State<Arc<AppState>>) -> impl IntoResponse {
+    let playlist = app_state.list.lock().await;
+    let template = IndexTemplate {
+        username: "User".to_string(),
+        playlist: playlist.clone(),
+        searched_musics: vec![],
+    };
+    templates::HtmlTemplate(template)
+}

jukebox_axum/src/main.rs

@@ -0,0 +1,49 @@
+use std::sync::Arc;
+use axum::extract::State;
+use axum::Form;
+use axum::response::{IntoResponse, Redirect};
+use my_youtube_extractor::youtube_info::YtVideoPageInfo;
+use serde::Deserialize;
+use crate::{AppState, MusicChange, templates};
+use crate::templates::index::IndexTemplate;
+
+#[derive(Debug, Deserialize)]
+pub struct SearchForm {
+    pub search: String,
+}
+
+#[axum::debug_handler]
+pub async fn search(
+    State(app_state): State<Arc<AppState>>,
+    search_form: Form<SearchForm>,
+) -> impl IntoResponse {
+    let videos = my_youtube_extractor::search_videos(&search_form.search).await;
+    let playlist: Vec<YtVideoPageInfo> = app_state.list.lock().await.clone();
+    let template = IndexTemplate {
+        username: "User".to_string(),
+        playlist,
+        searched_musics: videos,
+    };
+    templates::HtmlTemplate(template)
+}
+
+#[derive(Debug, Deserialize)]
+pub struct AddMusicForm {
+    pub video_serialized: String,
+}
+
+#[axum::debug_handler]
+pub async fn add_music(State(app_state): State<Arc<AppState>>, index_input: Form<AddMusicForm>) -> Redirect {
+    // TODO : do better
+    if let Ok(video) = serde_json::from_str::<YtVideoPageInfo>(&index_input.video_serialized[1..]) { // Remove the first '#' caracter
+        let mut added_video = false;
+        let mut playlist = app_state.list.lock().await;
+        added_video = true;
+        tracing::debug!("Video Add to playlist");
+        playlist.push(video.clone());
+    }
+    else {
+        tracing::warn!("Canno't parse the video : {}", index_input.video_serialized);
+    }
+    Redirect::to("/")
+}

jukebox_axum/src/search.rs

@@ -0,0 +1,20 @@
+pub mod index;
+
+use askama::Template;
+use axum::http::StatusCode;
+use axum::response::{Html, IntoResponse, Response};
+
+pub struct HtmlTemplate<T>(pub T);
+
+impl<T: Template> IntoResponse for HtmlTemplate<T> {
+    fn into_response(self) -> Response {
+        match self.0.render() {
+            Ok(html) => Html(html).into_response(),
+            Err(err) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Failed to render template. Error: {err}"),
+            )
+                .into_response(),
+        }
+    }
+}

jukebox_axum/src/templates.rs

@@ -0,0 +1,9 @@
+use askama::Template;
+
+#[derive(Template)]
+#[template(path = "index.html")]
+pub struct IndexTemplate {
+    pub username: String,
+    pub playlist: Vec<my_youtube_extractor::youtube_info::YtVideoPageInfo>,
+    pub searched_musics: Vec<my_youtube_extractor::youtube_info::YtVideoPageInfo>,
+}

jukebox_axum/src/templates/index.rs

@@ -0,0 +1,78 @@
+use std::sync::Arc;
+use axum::extract::{State, WebSocketUpgrade};
+use axum::extract::ws::{Message, WebSocket};
+use axum::response::IntoResponse;
+use futures::{sink::SinkExt, stream::StreamExt};
+use futures::stream::iter;
+use my_youtube_extractor::youtube_info::YtVideoPageInfo;
+use crate::AppState;
+
+pub enum NetData {
+    Remove(YtVideoPageInfo),
+    Add(YtVideoPageInfo),
+    Search(Vec<YtVideoPageInfo>),
+}
+
+fn video_data_to_string(video_info: &YtVideoPageInfo) -> String {
+    format!("({};{};{})", video_info.id, video_info.title, video_info.thumbnail)
+}
+
+impl ToString for NetData {
+    fn to_string(&self) -> String {
+        match self {
+            NetData::Remove(v) => format!("rem {}", video_data_to_string(v)),
+            NetData::Add(v) => format!("add {}", video_data_to_string(v)),
+            NetData::Search(s) => {
+                let videos_stringified: Vec<String> = s.iter().map(video_data_to_string).collect();
+                let res = videos_stringified.join("|");
+                format!("sch [{res}]")
+            }
+        }
+    }
+}
+
+impl NetData {
+    pub fn to_message(&self) -> Message {
+        Message::Text(self.to_string())
+    }
+}
+
+pub async fn websocket_handler(
+    ws: WebSocketUpgrade,
+    State(state): State<Arc<AppState>>,
+) -> impl IntoResponse {
+    ws.on_upgrade(|socket| websocket(socket, state))
+}
+
+async fn websocket(stream: WebSocket, state: Arc<AppState>) {
+    let (mut sender, mut receiver) = stream.split();
+
+    let mut rx = state.tx.subscribe();
+
+    let mut recv_user_task = tokio::spawn(async move {
+        while let Some(Ok(data)) = receiver.next().await {
+            if let Message::Text(data) = data {
+                tracing::info!("REMOVE SOMETHING: {:?}", data);
+                let video_id = &data[7..];
+                let mut playlist = state.list.lock().await;
+                if let Some((index, _)) = playlist.iter().enumerate().find(|(_, m)| m.id == video_id) {
+                    playlist.remove(index);
+                    state.tx.send(format!("rem {video_id}")).unwrap();
+                }
+            }
+        }
+    });
+
+    let mut broadcast_task = tokio::spawn(async move {
+        while let Ok(msg) = rx.recv().await {
+            if sender.send(Message::Text(msg)).await.is_err() {
+                break;
+            }
+        }
+    });
+
+    tokio::select! {
+        _ = (&mut broadcast_task) => recv_user_task.abort(),
+        _ = (&mut recv_user_task) => broadcast_task.abort(),
+    }
+}