//! API for the discover UI: mixes, suggested songs, and audio/cover streaming //! from Subsonic or YouTube. use crate::models::{ClusterMixRule, MixSuggestion}; use crate::subsonic::Subsonic; use crate::track::Track; use crate::youtube::YouTube; use futures_util::TryStreamExt; use rocket::http::Status; use rocket::request::{FromRequest, Outcome}; use rocket::response::{self, Responder}; use rocket::serde::json::Json; use rocket::{get, post, put, routes, Request, Response, Route, State}; use serde::{Deserialize, Serialize}; use sqlx::postgres::PgPool; use std::convert::Infallible; use std::sync::Arc; use tokio_util::io::StreamReader; use uuid::Uuid; pub fn routes() -> Vec { routes![rules, mixes, mix, liked, set_status, rebuild, stream, cover, youtube] } type ApiResult = Result, Status>; fn db_error(e: sqlx::Error) -> Status { match e { sqlx::Error::RowNotFound => Status::NotFound, e => { log::error!("Database error: {}", e); Status::InternalServerError } } } fn parse_id(id: &str) -> Result { Uuid::parse_str(id).map_err(|_| Status::NotFound) } #[get("/rules")] async fn rules(pool: &State) -> ApiResult> { ClusterMixRule::all(pool.inner()) .await .map(Json) .map_err(db_error) } #[derive(Serialize)] struct MixSummary { id: Uuid, playlist_id: String, name: Option, tags: Vec, position: i32, new_count: i64, } #[get("/rules//mixes")] async fn mixes(id: &str, pool: &State) -> ApiResult> { sqlx::query_as!( MixSummary, r#" SELECT p.id, p.playlist_id, p.name, p.tags, p.position, COUNT(s.id) FILTER (WHERE s.status = 'new') AS "new_count!" FROM "cluster_mix_playlist" p LEFT JOIN "mix_suggestion" s ON s.mix_id = p.id WHERE p.rule_id = $1 GROUP BY p.id ORDER BY p.position "#, parse_id(id)? ) .fetch_all(pool.inner()) .await .map(Json) .map_err(db_error) } #[derive(Serialize)] struct MixDetail { #[serde(flatten)] summary: MixSummary, songs: Vec, /// Songs in `songs` the user played recently known_song_ids: Vec, suggestions: Vec, } #[get("/mixes/")] async fn mix( id: &str, pool: &State, media_client: &State>, ) -> ApiResult { let id = parse_id(id)?; let summary = sqlx::query_as!( MixSummary, r#" SELECT p.id, p.playlist_id, p.name, p.tags, p.position, COUNT(s.id) FILTER (WHERE s.status = 'new') AS "new_count!" FROM "cluster_mix_playlist" p LEFT JOIN "mix_suggestion" s ON s.mix_id = p.id WHERE p.id = $1 GROUP BY p.id "#, id ) .fetch_one(pool.inner()) .await .map_err(db_error)?; let songs = media_client .get_playlist(&summary.playlist_id) .await .map_err(|e| { log::warn!("Could not load playlist {}: {}", summary.playlist_id, e); Status::BadGateway })? .entry; let known_song_ids = sqlx::query_scalar!( r#"SELECT known_song_ids FROM "cluster_mix_playlist" WHERE id = $1"#, id ) .fetch_one(pool.inner()) .await .map_err(db_error)?; let suggestions = sqlx::query_as!( MixSuggestion, r#" SELECT * FROM "mix_suggestion" WHERE mix_id = $1 AND status <> 'dismissed' ORDER BY score DESC "#, id ) .fetch_all(pool.inner()) .await .map_err(db_error)?; Ok(Json(MixDetail { summary, songs, known_song_ids, suggestions, })) } #[get("/rules//liked")] async fn liked(id: &str, pool: &State) -> ApiResult> { sqlx::query_as!( MixSuggestion, r#" SELECT * FROM "mix_suggestion" WHERE rule_id = $1 AND status = 'liked' ORDER BY created_at DESC "#, parse_id(id)? ) .fetch_all(pool.inner()) .await .map(Json) .map_err(db_error) } #[derive(Deserialize)] struct StatusUpdate { status: String, } /// Like, dismiss, or reset a suggestion #[put("/suggestions/", data = "")] async fn set_status( id: &str, update: Json, pool: &State, ) -> ApiResult { if !["new", "liked", "dismissed"].contains(&update.status.as_str()) { return Err(Status::UnprocessableEntity); } sqlx::query_as!( MixSuggestion, r#"UPDATE "mix_suggestion" SET status = $1 WHERE id = $2 RETURNING *"#, update.status, parse_id(id)? ) .fetch_one(pool.inner()) .await .map(Json) .map_err(db_error) } /// Rebuild a rule's mixes on the next daemon tick #[post("/rules//rebuild")] async fn rebuild(id: &str, pool: &State) -> Status { let Ok(id) = parse_id(id) else { return Status::NotFound; }; match sqlx::query!( r#"UPDATE "cluster_mix_rule" SET last_run = NULL WHERE id = $1"#, id ) .execute(pool.inner()) .await { Ok(r) if r.rows_affected() > 0 => Status::Accepted, Ok(_) => Status::NotFound, Err(e) => db_error(e), } } /// The request's Range header, so audio can be seeked pub struct Range(Option); #[rocket::async_trait] impl<'r> FromRequest<'r> for Range { type Error = Infallible; async fn from_request(request: &'r Request<'_>) -> Outcome { Outcome::Success(Range( request.headers().get_one("Range").map(str::to_string), )) } } /// Stream an upstream response through, keeping the headers a media element needs pub struct Proxied(reqwest::Response); impl<'r> Responder<'r, 'static> for Proxied { fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> { let upstream = self.0; let mut response = Response::build(); response.status(Status::new(upstream.status().as_u16())); for name in [ "content-type", "content-range", "accept-ranges", "cache-control", "last-modified", "etag", ] { if let Some(value) = upstream.headers().get(name).and_then(|v| v.to_str().ok()) { response.raw_header(name, value.to_string()); } } let size = upstream.content_length(); let body = StreamReader::new(upstream.bytes_stream().map_err(std::io::Error::other)); match size { // a known length lets browsers show durations and seek Some(size) => response.sized_body(size as usize, LengthReader(body)), None => response.streamed_body(body), }; response.ok() } } /// Rocket only accepts a known body length for seekable bodies, but never seeks one whose size /// is given up front. This satisfies the trait for a plain stream. struct LengthReader(R); impl tokio::io::AsyncRead for LengthReader { fn poll_read( mut self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>, buf: &mut tokio::io::ReadBuf<'_>, ) -> std::task::Poll> { std::pin::Pin::new(&mut self.0).poll_read(cx, buf) } } impl tokio::io::AsyncSeek for LengthReader { fn start_seek(self: std::pin::Pin<&mut Self>, _: std::io::SeekFrom) -> std::io::Result<()> { Err(std::io::Error::other("streamed body can't be seeked")) } fn poll_complete( self: std::pin::Pin<&mut Self>, _: &mut std::task::Context<'_>, ) -> std::task::Poll> { std::task::Poll::Ready(Err(std::io::Error::other("streamed body can't be seeked"))) } } /// Stream a song from Subsonic #[get("/stream/")] async fn stream( id: &str, range: Range, media_client: &State>, ) -> Result { let format = crate::CONFIG .get() .and_then(|c| c.get::("discover.format").ok()) .unwrap_or_else(|| "raw".to_string()); media_client .raw( "stream", &[("id", id.to_string()), ("format", format)], range.0.as_deref(), ) .await .map(Proxied) .map_err(|_| Status::BadGateway) } /// Cover art from Subsonic #[get("/cover/?")] async fn cover( id: &str, size: Option, media_client: &State>, ) -> Result { media_client .raw( "getCoverArt", &[ ("id", id.to_string()), ("size", size.unwrap_or(300).to_string()), ], None, ) .await .map(Proxied) .map_err(|_| Status::BadGateway) } /// Find a suggested song on YouTube and stream its audio #[get("/youtube/")] async fn youtube( id: &str, range: Range, pool: &State, youtube: &State, ) -> Result { let suggestion = sqlx::query_as!( MixSuggestion, r#"SELECT * FROM "mix_suggestion" WHERE id = $1"#, parse_id(id)? ) .fetch_one(pool.inner()) .await .map_err(db_error)?; let video_id = match suggestion.youtube_id { Some(video_id) => video_id, None => { let video_id = youtube .search(&suggestion.artist, &suggestion.title) .await .map_err(|e| { log::warn!( "YouTube search failed for {} - {}: {}", suggestion.artist, suggestion.title, e ); Status::BadGateway })? .ok_or(Status::NotFound)?; sqlx::query!( r#"UPDATE "mix_suggestion" SET youtube_id = $1 WHERE id = $2"#, video_id, suggestion.id ) .execute(pool.inner()) .await .map_err(db_error)?; video_id } }; // a cached URL may have expired; fetch a fresh one once for refresh in [false, true] { let url = youtube.audio_url(&video_id, refresh).await.map_err(|e| { log::warn!("Could not get audio for YouTube video {}: {}", video_id, e); Status::BadGateway })?; let mut request = youtube.client.get(url); if let Some(range) = &range.0 { request = request.header(reqwest::header::RANGE, range); } let response = request.send().await.map_err(|_| Status::BadGateway)?; if !refresh && matches!(response.status().as_u16(), 403 | 404 | 410) { continue; } return Ok(Proxied(response)); } Err(Status::BadGateway) }