router integration wip

Author: michaelb

STANCE.md

@@ -3,4 +3,4 @@
 Ultimately, ouverture is just a tool to help users manage and listen to their music collection. While it _can_ certainly be used to acquire DRM-protected content, so can many many other tools, such as [youtube-dl](https://github.com/ytdl-org/youtube-dl), and there are legal [precedent](https://github.blog/2020-11-16-standing-up-for-developers-youtube-dl-is-back/) in favor of the existence of such tools.
 
 
-While ouverture will do its best to not provide DRM-infringing defaults, it will neither implement mechanisms to prevent such usage, as per my (lead developper) personal opinion, although [thinly supported](https://qr.ae/pyJCdz), with regards to the actual revenues online services pay creators.
+While ouverture will do its best to not provide DRM-infringing defaults, it will neither implement mechanisms to prevent such usage, as per my (lead developper) personal opinion, although [thinly supported](https://qr.ae/pyJCdz), with regards to the actual revenues online services pay creators. Ouverture shall (at some point) provide convenient ways of directly supporting the creators.

ouverture-core/Cargo.toml

@@ -53,6 +53,7 @@ infer = "0.7"
 symphonia = { version = "0.5.2", features= ["all"]}
 
 rc_event_queue = "0.4.2"
+axum="0.7.3"
 
 
 [target.'cfg(target_os = "linux")'.dependencies]

ouverture-core/src/api_router.rs

@@ -0,0 +1,53 @@
+use std::net::{SocketAddr};
+use log::debug;
+use tokio::{net::{TcpListener, TcpStream}, task::JoinHandle};
+
+use std::sync::{Arc, Mutex};
+use crate::server::Server;
+
+use axum::{
+    routing::{get, post},
+    http::StatusCode,
+    Json, Router,
+};
+use serde::{Deserialize, Serialize};
+
+pub struct RouterTask{
+    pub addr: SocketAddr,
+    handle: JoinHandle<()>,
+    stop: Arc<Mutex<bool>>
+}
+
+pub async fn start_router() -> RouterTask {
+
+    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+
+    let addr = listener.local_addr().unwrap().clone();
+
+    let handle = tokio::spawn(async move {router(listener).await});
+
+    RouterTask {
+        addr,
+        handle,
+        stop: Arc::new(Mutex::new(false))
+    }
+
+}
+
+pub async fn stop_router(router: RouterTask){
+    let flag = router.stop;
+    *flag.lock().unwrap() = true;
+    router.handle.await.unwrap()
+
+}
+
+async fn router(listener: TcpListener) -> () {
+    debug!("launched API router");
+
+    let app = Router::new().route("/", get(root));
+    axum::serve(listener, app).await.unwrap();
+}
+
+async fn root() -> &'static str {
+    "Hello, World!"
+}

ouverture-core/src/lib.rs

@@ -6,6 +6,7 @@ pub mod library;
 pub mod logger;
 pub mod music;
 pub mod server;
+pub mod api_router;
 
 use config::Config;
 use server::Server;

ouverture-core/src/server.rs

@@ -3,6 +3,7 @@ use bincode;
 use futures_core::stream::Stream;
 use serde::{Deserialize, Serialize};
 use std::error::Error;
+use std::net::SocketAddrV4;
 use std::sync::{Arc, Mutex};
 use strum_macros::{Display, EnumIter, EnumString};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -20,14 +21,16 @@ use log::{debug, error, info, trace, warn};
 use tokio::runtime::Runtime;
 
 use crate::audio::AudioTask;
+use crate::api_router::{RouterTask, start_router};
 
-// magic number to identify ovuerture protocol on the wire
+// magic number to identify ouverture protocol on the wire
 const MAGIC_ID_OUVERTURE_PROTOCOL: u64 = 0xACDE314152960000;
 
 pub struct Server {
     config: Config,
     audio_task: Option<AudioTask>, // this task has for only role to send queued songs to the audio thread
     // when it finishes playing a song
+    router_task: Option<RouterTask>,
     state: Arc<Mutex<ServerState>>,
 }
 
@@ -43,6 +46,7 @@ impl Server {
         Self {
             config: config.clone(),
             audio_task: None,
+            router_task: None,
             state,
         }
     }
@@ -57,6 +61,9 @@ impl Server {
         self.audio_task = Some(AudioTask::run());
         let audio_state = self.audio_task.as_ref().unwrap().state.clone();
 
+        self.router_task = Some(start_router().await);
+        let internal_router_address = self.router_task.unwrap().addr;
+
         // accept many clients at the same time
         let res = loop {
             let (mut socket, _) = listener.accept().await?;
@@ -67,6 +74,8 @@ impl Server {
             let state = self.state.clone();
             let audio_state = audio_state.clone();
 
+            let mut internal_stream = TcpStream::connect(internal_router_address).await?;
+
             let config = self.config.clone();
             let handle = tokio::spawn(async move {
                 let mut buf = [0u8; 8];