diff options
| -rw-r--r-- | src/cache.rs | 9 | ||||
| -rw-r--r-- | src/cache/font.rs (renamed from src/font.rs) | 21 | ||||
| -rw-r--r-- | src/cache/user.rs | 101 | ||||
| -rw-r--r-- | src/config.rs | 124 | ||||
| -rw-r--r-- | src/ctx.rs | 10 | ||||
| -rw-r--r-- | src/deserialize.rs | 16 | ||||
| -rw-r--r-- | src/http.rs | 9 | ||||
| -rw-r--r-- | src/lib.rs | 5 | ||||
| -rw-r--r-- | src/main.rs | 18 |
9 files changed, 168 insertions, 145 deletions
diff --git a/src/cache.rs b/src/cache.rs index a6f25fa..cf612b6 100644 --- a/src/cache.rs +++ b/src/cache.rs @@ -1,3 +1,6 @@ +pub mod font; +pub mod user; + use std::future::Future; use std::time::*; use std::collections::HashMap; @@ -31,10 +34,10 @@ where pub async fn get(&mut self, key: &K) -> Result<&V, (StatusCode, &'static str)> { if self.is_stale(key) { - log::trace!(target: "lfm::cache", "MISS : interval = {:?}", self.interval); + log::trace!("MISS : interval = {:?}", self.interval); self.renew(key).await } else { - log::trace!(target: "lfm::cache", "HIT : interval = {:?}", self.interval); + log::trace!("HIT : interval = {:?}", self.interval); Ok(&self.cache.get(key).unwrap().1) } } @@ -48,7 +51,7 @@ where pub fn is_stale(&self, key: &K) -> bool { if let Some((last_update, _)) = self.cache.get(key) { let now = Instant::now(); - log::trace!(target: "lfm::cache", "Key exists, last update {:?} ago.", now - *last_update); + log::trace!("Key exists, last update {:?} ago.", now - *last_update); now > (*last_update + self.interval) } else { true } diff --git a/src/font.rs b/src/cache/font.rs index 6454770..c17247d 100644 --- a/src/font.rs +++ b/src/cache/font.rs @@ -1,11 +1,12 @@ use std::sync::Arc; use std::time::Duration; +use std::sync::LazyLock; use tokio::sync::RwLock; -use reqwest::StatusCode; +use reqwest::{StatusCode, Client}; -use super::cache::{CacheFuture, CacheGetter, Cache, AsyncCache}; -use crate::STATE; +use super::{CacheFuture, CacheGetter, Cache, AsyncCache}; +use crate::CONFIG; #[derive(serde::Deserialize, Debug, Default)] #[serde(default)] @@ -24,12 +25,12 @@ pub type FontCache = Cache<Arc<str>>; fn font_getter(fontname: &String) -> FontFuture { let fontname = urlencoding::encode(fontname.as_ref()).to_string(); Box::pin(async move { - let Some(google_api_key) = STATE.google_api_key.clone() + let Some(google_api_key) = CONFIG.google_api_key.clone() else { unreachable!(); }; - let fontreq = STATE.http.get(format!("https://www.googleapis.com/webfonts/v1/webfonts?key={}&family={fontname}", google_api_key)) + let fontreq = HTTP.get(format!("https://www.googleapis.com/webfonts/v1/webfonts?key={}&family={fontname}", google_api_key)) .send().await .map_err(|e| {log::error!("Failed to get info for font `{fontname}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to Google Fonts!")})?; if fontreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "Font does not exist!")); } @@ -38,7 +39,7 @@ fn font_getter(fontname: &String) -> FontFuture { return Err((StatusCode::SERVICE_UNAVAILABLE, "This instance is not configured to support Google Fonts properly, please use a different font.")); } - let cssreq = STATE.http.get(format!("https://fonts.googleapis.com/css2?family={fontname}")) + let cssreq = HTTP.get(format!("https://fonts.googleapis.com/css2?family={fontname}")) .send().await .map_err(|e| {log::error!("Failed to get CSS for font `{fontname}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't download font CSS!")})?; @@ -46,6 +47,12 @@ fn font_getter(fontname: &String) -> FontFuture { }) } -pub fn font_cache() -> FontCache { +static HTTP: LazyLock<Client> = crate::http::lazy(); + +static FONT_CACHE: LazyLock<FontCache> = LazyLock::new(|| { Arc::new(RwLock::new(AsyncCache::new(Duration::from_secs(86400), font_getter as FontGetter))) +}); + +pub async fn get_fontinfo(font: &String) -> Result<Arc<str>, (StatusCode, &'static str)> { + FONT_CACHE.write().await.get_owned(font).await } diff --git a/src/cache/user.rs b/src/cache/user.rs new file mode 100644 index 0000000..c3b6f04 --- /dev/null +++ b/src/cache/user.rs @@ -0,0 +1,101 @@ +use std::sync::Arc; +use std::time::Duration; +use std::sync::LazyLock; + +use tokio::sync::RwLock; +use reqwest::{StatusCode, Client}; + +use super::{CacheFuture, CacheGetter, Cache, AsyncCache}; +use crate::deserialize::{User, Track, TrackStub}; +use crate::CONFIG; + +type UserFuture = CacheFuture<Arc<(User, Track, TrackStub)>>; +type UserGetter = CacheGetter<Arc<(User, Track, TrackStub)>>; +type UserCache = Cache<Arc<(User, Track, TrackStub)>>; + +#[derive(Debug)] +enum Whitelist { + Exclusive{cache: UserCache}, + Open{default_cache: UserCache, whitelist_cache: UserCache} +} + +fn user_getter(username: &String) -> UserFuture { + use crate::deserialize::{GetUserInfo, GetRecentTracks, GetTrackInfo}; + + let username = urlencoding::encode(username.as_ref()).to_string(); + Box::pin(async move { + let userreq = HTTP.get(format!("https://ws.audioscrobbler.com/2.0/?method=user.getInfo&format=json&user={username}&api_key={}", CONFIG.lastfm_api_key)) + .send().await + .map_err(|e| {log::error!("Failed to get info for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?; + if userreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "User does not exist!")); } + + let userstr = userreq.text().await.unwrap(); + log::trace!("Got user.getUserInfo JSON for `{username}`: {userstr}"); + let userinfo = serde_json::from_str::<GetUserInfo>(&userstr) + .map_err(|e| {log::error!("Couldn't parse user.getInfo for `{username}`: {e}"); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse user.getInfo!")})?.user; + + let tracksreq = HTTP.get(format!("https://ws.audioscrobbler.com/2.0/?method=user.getRecentTracks&format=json&extended=1&limit=1&user={username}&api_key={}", CONFIG.lastfm_api_key)) + .send().await + .map_err(|e| {log::error!("Failed to get tracks for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?; + if tracksreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "User does not exist!")); } + if tracksreq.status() == StatusCode::FORBIDDEN { return Err((StatusCode::FORBIDDEN, "You need to unprivate your song history!")); } + + let tracksstr = tracksreq.text().await.unwrap(); + log::trace!("Got user.getRecentTracks JSON for `{username}`: {tracksstr}"); + let trackstub = serde_json::from_str::<GetRecentTracks>(&tracksstr) + .map_err(|e| {log::error!("Couldn't parse user.getRecentTracks for `{username}`: {e}"); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse user.getRecentTracks!")})? + .recenttracks.track.into_iter().next().ok_or((StatusCode::UNPROCESSABLE_ENTITY, "You need to listen to some songs first!"))?; + + let trackreq = HTTP.get(format!("https://ws.audioscrobbler.com/2.0/?method=track.getInfo&format=json&username={username}&api_key={}&track={}&artist={}", CONFIG.lastfm_api_key, trackstub.name, trackstub.artist.name)) + .send().await + .map_err(|e| {log::error!("Failed to get tracks for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?; + if trackreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "Track does not exist!")); } + + let trackstr = trackreq.text().await.unwrap(); + log::trace!("Got user.getTrackInfo JSON for `{username}`: {trackstr}"); + let trackinfo = serde_json::from_str::<GetTrackInfo>(&trackstr) + .map_err(|e| {log::error!("Couldn't parse track.getInfo for `{}` by `{}` on behalf of {username}: {e}", trackstub.name, trackstub.artist.name); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse track.getInfo!")})?.track; + + Ok(Arc::new((userinfo, trackinfo, trackstub))) + }) +} + +static HTTP: LazyLock<Client> = crate::http::lazy(); + +static WHITELIST: LazyLock<Whitelist> = LazyLock::new(|| { + let default_cache = Arc::new(RwLock::new(AsyncCache::new(CONFIG.default_refresh, user_getter as UserGetter))); + let whitelist_cache = Arc::new(RwLock::new(AsyncCache::new(CONFIG.whitelist_refresh, user_getter as UserGetter))); + match CONFIG.whitelist_mode.as_str() { + "open" => { + Whitelist::Open{default_cache, whitelist_cache} + }, + "exclusive" => { + if CONFIG.whitelist.is_empty() { + panic!("Exclusive mode set with empty whitelist, cannot serve any requests!"); + } + Whitelist::Exclusive{cache: whitelist_cache} + }, + m => { + panic!("Bad whitelist mode: `{m}`"); + } + } +}); + +pub async fn get_userinfo(user: &String) -> (Result<Arc<(User, Track, TrackStub)>, (StatusCode, &'static str)>, Duration) { + match LazyLock::force(&WHITELIST) { + Whitelist::Open{default_cache, whitelist_cache} => { + if CONFIG.whitelist.contains(user) { + (whitelist_cache.write().await.get_owned(user).await, CONFIG.whitelist_refresh) + } + else { + (default_cache.write().await.get_owned(user).await, CONFIG.default_refresh) + } + }, + Whitelist::Exclusive{cache} => { + if CONFIG.whitelist.contains(user) { + (cache.write().await.get_owned(user).await, CONFIG.whitelist_refresh) + } + else { (Err((StatusCode::FORBIDDEN, "User not in whitelist!")), CONFIG.default_refresh) } + } + } +} diff --git a/src/config.rs b/src/config.rs index 3c11bc8..69328b0 100644 --- a/src/config.rs +++ b/src/config.rs @@ -7,103 +7,46 @@ use std::time::*; use super::cache::AsyncCache; use super::deserialize::{GetRecentTracks, GetUserInfo, GetTrackInfo, Track, TrackStub, User}; -use super::font::{font_cache, FontCache}; -use reqwest::{Client, StatusCode}; use dotenv::var; use tokio::sync::RwLock; use handlebars::{Handlebars, handlebars_helper}; use duration_str as ds; -type CacheFuture<Output> = Pin<Box<(dyn Future<Output = Result<Output, (StatusCode, &'static str)>> + Send + Sync)>>; -type CacheGetter<Output> = fn(&String) -> CacheFuture<Output>; -type Cache<Output> = Arc<RwLock<AsyncCache<String, Output, CacheGetter<Output>>>>; - -type UserFuture = CacheFuture<Arc<(User, Track, TrackStub)>>; -type UserGetter = CacheGetter<Arc<(User, Track, TrackStub)>>; -type UserCache = Cache<Arc<(User, Track, TrackStub)>>; - static INTERNAL_THEMES: &[(&str, &str)] = &[("plain", include_str!("themes/plain.hbs"))]; -pub static STATE: LazyLock<Arc<State>> = LazyLock::new(|| { - State::new() +pub static CONFIG: LazyLock<Arc<Config>> = LazyLock::new(|| { + Config::new() }); -fn user_getter(username: &String) -> UserFuture { - let username = urlencoding::encode(username.as_ref()).to_string(); - Box::pin(async move { - let userreq = STATE.http.get(format!("https://ws.audioscrobbler.com/2.0/?method=user.getInfo&format=json&user={username}&api_key={}", STATE.lastfm_api_key)) - .send().await - .map_err(|e| {log::error!("Failed to get info for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?; - if userreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "User does not exist!")); } - - let userinfo = userreq.json::<GetUserInfo>().await - .map_err(|e| {log::error!("Couldn't parse user.getInfo for `{username}`: {e}"); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse user.getInfo!")})?.user; - - let tracksreq = STATE.http.get(format!("https://ws.audioscrobbler.com/2.0/?method=user.getRecentTracks&format=json&extended=1&limit=1&user={username}&api_key={}", STATE.lastfm_api_key)) - .send().await - .map_err(|e| {log::error!("Failed to get tracks for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?; - if tracksreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "User does not exist!")); } - if tracksreq.status() == StatusCode::FORBIDDEN { return Err((StatusCode::FORBIDDEN, "You need to unprivate your song history!")); } - - let trackstub = tracksreq.json::<GetRecentTracks>().await - .map_err(|e| {log::error!("Couldn't parse user.getRecentTracks for `{username}`: {e}"); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse user.getRecentTracks!")})? - .recenttracks.track.into_iter().next().ok_or((StatusCode::UNPROCESSABLE_ENTITY, "You need to listen to some songs first!"))?; - - let trackreq = STATE.http.get(format!("https://ws.audioscrobbler.com/2.0/?method=track.getInfo&format=json&username={username}&api_key={}&track={}&artist={}", STATE.lastfm_api_key, trackstub.name, trackstub.artist.name)) - .send().await - .map_err(|e| {log::error!("Failed to get tracks for user `{username}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't connect to last.fm!")})?; - if trackreq.status() == StatusCode::NOT_FOUND { return Err((StatusCode::NOT_FOUND, "Track does not exist!")); } - - let trackinfo = trackreq.json::<GetTrackInfo>().await - .map_err(|e| {log::error!("Couldn't parse track.getInfo for `{}` by `{}` on behalf of {username}: {e}", trackstub.name, trackstub.artist.name); (StatusCode::INTERNAL_SERVER_ERROR, "Couldn't parse track.getInfo!")})?.track; - - Ok(Arc::new((userinfo, trackinfo, trackstub))) - }) -} - #[derive(Debug)] -enum Whitelist { - Exclusive{cache: UserCache, whitelist: BTreeSet<String>}, - Open{default_cache: UserCache, whitelist_cache: UserCache, whitelist: BTreeSet<String>} -} -#[derive(Debug)] -pub struct State { - lastfm_api_key: Arc<str>, +pub struct Config { + pub(crate) lastfm_api_key: Arc<str>, port: u16, default_theme: Arc<str>, send_refresh_header: bool, - pub(crate) http: Client, - handlebars: Handlebars<'static>, - pub(crate) google_api_key: Option<Arc<str>>, - google_fonts_cache: FontCache, + pub(crate )google_api_key: Option<Arc<str>>, - whitelist: Whitelist, - default_refresh: Duration, - whitelist_refresh: Duration, + pub(crate) whitelist: BTreeSet<String>, + pub(crate) whitelist_mode: String, + pub(crate) default_refresh: Duration, + pub(crate) whitelist_refresh: Duration, } -impl State { +impl Config { fn new() -> Arc<Self> { let duration_from_var = |v: &str, d: u64| -> Duration {var(v).map(|r| ds::parse(&r).expect("bad duration string")).unwrap_or_else(|_| Duration::from_secs(d))}; - let user_cache_from_duration = |d: Duration| -> UserCache { - Arc::new(RwLock::new(AsyncCache::new(d, user_getter as UserGetter))) - }; let default_refresh = duration_from_var("LFME_DEFAULT_REFRESH", 300); let whitelist_refresh = duration_from_var("LFME_WHITELIST_REFRESH", 60); - let default_cache = user_cache_from_duration(default_refresh); - let whitelist_cache = user_cache_from_duration(whitelist_refresh); - Arc::new(State { + Arc::new(Config { lastfm_api_key: var("LFME_LASTFM_API_KEY").expect("last.fm API key must be set").into(), port: var("LFME_PORT").map(|p| p.parse().expect("cannot parse as a port number")).unwrap_or(9999), default_theme: var("LFME_THEME_DEFAULT").map(Into::into).unwrap_or_else(|_| "plain".into()), send_refresh_header: !var("LFME_NO_REFRESH").map(|h| &h == "1").unwrap_or(false), - http: Client::builder().https_only(true).user_agent(concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"))).build().unwrap(), - handlebars: { let mut hb = Handlebars::new(); handlebars_helper!(url_encode: |s: String| urlencoding::encode(&s)); @@ -125,27 +68,9 @@ impl State { }, google_api_key: var("LFME_GOOGLE_API_KEY").map(Into::into).ok(), - google_fonts_cache: font_cache(), - - whitelist: { - let load_whitelist = || -> Option<BTreeSet<String>> { - var("LFME_WHITELIST").ok().map( - |w| w.split(',').map(|s| s.trim().to_string()).collect() - ) - }; - - match var("LFME_WHITELIST_MODE").map(|m| m.to_ascii_lowercase()).unwrap_or_else(|_| "open".into()).as_str() { - "open" => { - Whitelist::Open{default_cache, whitelist_cache, whitelist: load_whitelist().unwrap_or_default()} - }, - "exclusive" => { - Whitelist::Exclusive{cache: whitelist_cache, whitelist: load_whitelist().expect("LFME_WHITELIST not set, unable to serve anyone")} - }, - m => { - panic!("Bad whitelist mode: `{m}`"); - } - } - }, + + whitelist: var("LFME_WHITELIST").ok().map(|w| w.split(',').map(|s| s.trim().to_string()).collect()).unwrap_or_default(), + whitelist_mode: var("LFME_WHITELIST_MODE").map(|m| m.to_ascii_lowercase()).unwrap_or_else(|_| "open".into()), default_refresh: default_refresh + Duration::from_secs(1), whitelist_refresh: whitelist_refresh + Duration::from_secs(1) }) @@ -153,28 +78,7 @@ impl State { pub fn port(&self) -> u16 { self.port } pub fn send_refresh_header(&self) -> bool { self.send_refresh_header } - pub async fn get_fontinfo(&self, font: &String) -> Result<Arc<str>, (StatusCode, &'static str)> { - self.google_fonts_cache.write().await.get_owned(font).await - } pub fn has_google_api_key(&self) -> bool { self.google_api_key.is_some() } - pub async fn get_userinfo(&self, user: &String) -> (Result<Arc<(User, Track, TrackStub)>, (StatusCode, &'static str)>, Duration) { - match &self.whitelist { - Whitelist::Open{default_cache, whitelist_cache, whitelist} => { - if whitelist.contains(user) { - (whitelist_cache.write().await.get_owned(user).await, self.whitelist_refresh) - } - else { - (default_cache.write().await.get_owned(user).await, self.default_refresh) - } - }, - Whitelist::Exclusive{cache, whitelist} => { - if whitelist.contains(user) { - (cache.write().await.get_owned(user).await, self.whitelist_refresh) - } - else { (Err((StatusCode::FORBIDDEN, "User not in whitelist!")), self.default_refresh) } - } - } - } pub fn handlebars(&self) -> &Handlebars { &self.handlebars } pub fn default_theme(&self) -> Arc<str> { self.default_theme.clone() } } @@ -2,8 +2,8 @@ use reqwest::StatusCode; use super::deserialize as de; use std::sync::Arc; use std::collections::BTreeMap; -use super::font::FontQuery; -use super::config::STATE; +use crate::cache::font::FontQuery; +use super::config::CONFIG; pub mod model { use std::sync::Arc; @@ -126,7 +126,7 @@ impl ResponseCtx { }, scrobble: model::Scrobble { name: track.name.clone(), - album: track.album.name.clone(), + album: track.album.title.clone(), artist: model::Artist { name: track.artist.name.clone(), // image_url: track.artist.images.iter().max_by(|a, b| a.size.cmp(&b.size)).map(|a| a.url.clone()).unwrap_or_else(|| "".into()), @@ -138,8 +138,8 @@ impl ResponseCtx { loved: track.loved.unwrap_or(false) }, font: match font_query { - Some(FontQuery { google_font: Some(f), .. }) if STATE.has_google_api_key() => { - let css = match STATE.get_fontinfo(&f.to_string()).await { + Some(FontQuery { google_font: Some(f), .. }) if CONFIG.has_google_api_key() => { + let css = match crate::cache::font::get_fontinfo(&f.to_string()).await { Ok(css) => css, Err((status, error)) => { return ResponseCtx(model::Root::Error {error}, status); } }; diff --git a/src/deserialize.rs b/src/deserialize.rs index 9606258..0134ae5 100644 --- a/src/deserialize.rs +++ b/src/deserialize.rs @@ -82,16 +82,15 @@ pub enum ImageSize { #[derive(Deserialize, Debug)] pub struct Image { pub size: ImageSize, - #[serde(rename = "#text")] + #[serde(alias = "#text")] pub url: Arc<str>, } #[derive(Deserialize, Debug)] pub struct Album { - #[serde(rename = "mbid")] - pub uuid: Arc<str>, - #[serde(rename = "#text")] - pub name: Arc<str>, + pub mbid: Option<Arc<str>>, + #[serde(alias = "#text")] + pub title: Arc<str>, #[serde(default)] #[serde(rename = "image")] pub images: Vec<Image>, @@ -102,9 +101,10 @@ pub struct Album { #[derive(Deserialize, Debug)] pub struct Track { pub artist: Artist, - #[serde(rename = "image")] + #[serde(alias = "image")] + #[serde(default)] pub images: Vec<Image>, - pub mbid: Arc<str>, + pub mbid: Option<Arc<str>>, pub album: Album, pub name: Arc<str>, pub url: Arc<str>, @@ -138,7 +138,7 @@ pub struct TrackAttr { } #[derive(Deserialize, Debug)] pub struct ArtistStub { - #[serde(rename = "#text")] + #[serde(alias = "#text")] pub name: Arc<str> } #[derive(Deserialize, Debug)] diff --git a/src/http.rs b/src/http.rs new file mode 100644 index 0000000..f0a609b --- /dev/null +++ b/src/http.rs @@ -0,0 +1,9 @@ +use std::sync::LazyLock; +use reqwest::Client; + +pub(crate) fn new() -> Client { + Client::builder().https_only(true).user_agent(concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"))).build().unwrap() +} +pub(crate) const fn lazy() -> LazyLock<Client> { + LazyLock::new(new) +} @@ -1,10 +1,11 @@ #![feature(lazy_cell)] +mod http; + pub mod deserialize; pub mod cache; pub mod config; pub mod ctx; -pub mod font; -pub use config::STATE; +pub use config::CONFIG; pub use ctx::ResponseCtx; diff --git a/src/main.rs b/src/main.rs index cf7856a..38ee31f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,8 +5,8 @@ use log::LevelFilter; use std::collections::BTreeMap; use std::fs::File; use std::sync::Arc; -use lfm_embed::{STATE, ResponseCtx}; -use lfm_embed::font::FontQuery; +use lfm_embed::{CONFIG, ResponseCtx}; +use lfm_embed::cache::font::FontQuery; use warp::Filter; #[derive(serde::Deserialize, Debug)] @@ -38,22 +38,20 @@ async fn main() { .unwrap_or(env_logger::Target::Stderr) ).init(); - std::sync::LazyLock::force(&STATE); - let user = warp::path!("user" / String) .and(warp::query::<UserQuery>()) .then(|s, q: UserQuery| async move { - log::debug!(target: "lfm::server::user", "Handling request for user `{s}` with {q:?}"); - let (ctx, dur) = STATE.get_userinfo(&s).await; + log::debug!(target: "lfm_embed::server::user", "Handling request for user `{s}` with {q:?}"); + let (ctx, dur) = lfm_embed::cache::user::get_userinfo(&s).await; let ResponseCtx(data, status) = ResponseCtx::create(ctx, q.font, q.rest).await; - let theme = q.theme.filter(|a| STATE.handlebars().has_template(a)).unwrap_or_else(|| STATE.default_theme()); - log::debug!(target: "lfm::server::user", "Using theme {theme}"); + let theme = q.theme.filter(|a| CONFIG.handlebars().has_template(a)).unwrap_or_else(|| CONFIG.default_theme()); + log::debug!(target: "lfm_embed::server::user", "Using theme {theme}"); warp::reply::with_header( warp::reply::with_header( warp::reply::with_status( warp::reply::html( - STATE.handlebars().render(&theme, &data).unwrap() + CONFIG.handlebars().render(&theme, &data).unwrap() ), status ), "Refresh", dur.as_secs() ), "X-Selected-Theme", theme.as_ref() @@ -61,5 +59,5 @@ async fn main() { }); warp::serve(user) - .bind(([127,0,0,1], STATE.port())).await; + .bind(([127,0,0,1], CONFIG.port())).await; } |