Add http server with mpmc communication for mpris player

src/database.rs

@@ -3,6 +3,7 @@ use std::i64;
 use anyhow::Result;
 use sqlx::{Row, SqlitePool};
 
+#[derive(Clone)]
 pub struct Database {
     pool: SqlitePool,
 }

src/http_server.rs

@@ -0,0 +1,63 @@
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use tokio::sync::broadcast::Sender;
+
+use crate::database::Database;
+
+#[derive(Clone)]
+struct SharedState {
+    database: Database,
+    mpris_sender: Sender<(String, String)>,
+}
+
+pub async fn http_serve(database: &Database, mpris_producer: Sender<(String, String)>) {
+    let database = database.clone();
+    let shared_state = SharedState {
+        database,
+        mpris_sender: mpris_producer,
+    };
+
+    let app = Router::new()
+        .route("/", get(root))
+        .route("/{length}", get(add_rating))
+        .with_state(shared_state);
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+
+async fn root() -> impl IntoResponse {
+    (StatusCode::OK, "Use /{user_id}/{rating}")
+}
+
+async fn add_rating(
+    Path((user_id, rating)): Path<(i64, i64)>,
+    State(shared): State<SharedState>,
+) -> Response {
+    // Get the current interpret and track from the broadcast channel
+    match shared.mpris_sender.subscribe().recv().await {
+        Ok((interpret, track)) => {
+            // write to db
+            match shared
+                .database
+                .user_add_rating(user_id, &interpret, &track, rating)
+                .await
+            {
+                Ok(_) => (StatusCode::OK, "Done.").into_response(),
+                Err(e) => {
+                    println!("HTTP error: {e}");
+                    (StatusCode::BAD_REQUEST, e.to_string()).into_response()
+                }
+            }
+        }
+        Err(e) => {
+            println!("mpris error: {e}");
+            (StatusCode::BAD_REQUEST, e.to_string()).into_response()
+        }
+    }
+}

src/main.rs

@@ -1,9 +1,11 @@
 mod database;
+mod http_server;
 mod player;
 mod userinterface;
 
-use std::env::args;
-use tokio;
+use std::{env::args, sync::Arc};
+
+use tokio::sync::broadcast;
 
 #[tokio::main]
 async fn main() {
@@ -11,9 +13,11 @@ async fn main() {
     let player = player::MprisPlayer::new().expect("Could not create player");
 
     // Initialize the database
-    let db = database::Database::new()
-        .await
-        .expect("Could not create database");
+    let db = Arc::new(
+        database::Database::new()
+            .await
+            .expect("Could not create database"),
+    );
 
     // Create the tables on an empty database
     db.create_tables().await.unwrap();
@@ -57,6 +61,27 @@ async fn main() {
         return;
     }
 
+    // Instantiate the mpris channel
+    let (mpris_tx, _) = broadcast::channel(32);
+
+    let mpris_tx_http = mpris_tx.clone();
+    tokio::spawn(async move {
+        let player = player::MprisPlayer::new().expect("Could not create player");
+        loop {
+            if let Ok((interpret, track)) = player.get_interpret_and_track() {
+                if let Err(e) = mpris_tx.send((interpret, track)) {
+                    println!("Error sending interpret and track: {e}");
+                }
+            }
+        }
+    });
+
+    // Create the HTTP backend
+    let db_http = db.clone();
+    tokio::spawn(async move {
+        http_server::http_serve(&db_http, mpris_tx_http).await;
+    });
+
     loop {
         let (usernumber, userrating) = userinterface::get_user_rating(&db)
             .await
@@ -78,3 +103,7 @@ async fn main() {
         }
     }
 }
+
+fn mpris_player_producer() {
+    //
+}