From d2c27e17897f80929d2ba5fed1055eade27a6b08 Mon Sep 17 00:00:00 2001 From: alyx Date: Fri, 12 Jan 2024 12:17:57 -0500 Subject: Cleanup --- src/config.rs | 248 +++++++++++++++++++++++++++++----------------------------- 1 file changed, 124 insertions(+), 124 deletions(-) (limited to 'src/config.rs') diff --git a/src/config.rs b/src/config.rs index 8492f8b..49b515e 100644 --- a/src/config.rs +++ b/src/config.rs @@ -1,4 +1,4 @@ -use std::collections::{HashMap, HashSet}; +use std::collections::BTreeSet; use std::sync::LazyLock; use std::sync::Arc; use std::future::Future; @@ -17,32 +17,32 @@ use duration_str as ds; static INTERNAL_THEMES: &[(&'static str, &'static str)] = &[("plain", include_str!("themes/plain.hbs"))]; pub static STATE: LazyLock> = LazyLock::new(|| { - State::new() + State::new() }); fn user_getter(username: &String) -> Pin, (StatusCode, &'static str)>> + Send + Sync)>> { - 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::().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 tracksinfo = tracksreq.json::().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().nth(0).ok_or((StatusCode::UNPROCESSABLE_ENTITY, "You need to listen to some songs first!"))?; - - Ok(Arc::new((userinfo, tracksinfo))) - }) + 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::().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 tracksinfo = tracksreq.json::().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().nth(0).ok_or((StatusCode::UNPROCESSABLE_ENTITY, "You need to listen to some songs first!"))?; + + Ok(Arc::new((userinfo, tracksinfo))) + }) } fn font_getter(fontname: &String) -> Pin, (StatusCode, &'static str)>> + Send + Sync)>> { @@ -76,117 +76,117 @@ type FontGetter = fn(&String) -> Pin, ( type FontCache = Arc, FontGetter>>>; #[derive(Debug)] enum Whitelist { - Exclusive{cache: UserCache, whitelist: HashSet}, - Open{default_cache: UserCache, whitelist_cache: UserCache, whitelist: HashSet} + Exclusive{cache: UserCache, whitelist: BTreeSet}, + Open{default_cache: UserCache, whitelist_cache: UserCache, whitelist: BTreeSet} } #[derive(Debug)] pub struct State { - lastfm_api_key: Arc, - google_api_key: Option>, - whitelist: Whitelist, - port: u16, + lastfm_api_key: Arc, + port: u16, + default_theme: Arc, + send_refresh_header: bool, - handlebars: Handlebars<'static>, - default_theme: Arc, - send_refresh_header: bool, - http: Client, + http: Client, - google_fonts_cache: FontCache, + handlebars: Handlebars<'static>, - default_refresh: Duration, - whitelist_refresh: Duration, + google_api_key: Option>, + google_fonts_cache: FontCache, + + whitelist: Whitelist, + default_refresh: Duration, + whitelist_refresh: Duration, } impl State { - fn new() -> Arc { - 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))) + fn new() -> Arc { + 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 { + 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)); + + hb.register_helper("url-encode", Box::new(url_encode)); + + for (key, fulltext) in INTERNAL_THEMES { + log::info!(target: "lfm::config::theme", "Registering internal theme `{key}`"); + hb.register_template_string(key, fulltext).unwrap(); + } + hb.set_dev_mode(var("LFME_THEME_DEV").map(|h| &h == "1").unwrap_or(false)); + + if let Ok(themes_dir) = var("LFME_THEME_DIR") { + log::info!(target: "lfm::config::theme", "Registering theme dir `{themes_dir}`"); + hb.register_templates_directory(&var("LFME_THEME_EXT").unwrap_or_else(|_| ".hbs".into()), themes_dir).unwrap(); + } + + hb + }, + + google_api_key: var("LFME_GOOGLE_API_KEY").map(Into::into).ok(), + google_fonts_cache: Arc::new(RwLock::new(AsyncCache::new(Duration::from_secs(86400), font_getter as FontGetter))), + + whitelist: { + let load_whitelist = || -> Option> { + var("LFME_WHITELIST").ok().map( + |w| w.split(",").map(|s| s.trim().to_string()).collect() + ) }; - 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 { - 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), - 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)); - - hb.register_helper("url-encode", Box::new(url_encode)); - - for (key, fulltext) in INTERNAL_THEMES { - log::info!(target: "lfm::config::theme", "Registering internal theme `{key}`"); - hb.register_template_string(key, fulltext).unwrap(); - } - hb.set_dev_mode(var("LFME_THEME_DEV").map(|h| &h == "1").unwrap_or(false)); - - if let Ok(themes_dir) = var("LFME_THEME_DIR") { - log::info!(target: "lfm::config::theme", "Registering theme dir `{themes_dir}`"); - hb.register_templates_directory(&var("LFME_THEME_EXT").unwrap_or_else(|_| ".hbs".into()), themes_dir).unwrap(); - } - - hb - }, - default_theme: var("LFME_THEME_DEFAULT").map(Into::into).unwrap_or_else(|_| "plain".into()), - - google_api_key: var("LFME_GOOGLE_API_KEY").map(Into::into).ok(), - google_fonts_cache: Arc::new(RwLock::new(AsyncCache::new(Duration::from_secs(86400), font_getter as FontGetter))), - - whitelist: { - let load_whitelist = || -> Option> { - 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}`"); - } - } - }, - default_refresh: default_refresh + Duration::from_secs(1), - whitelist_refresh: whitelist_refresh + Duration::from_secs(1) - }) - } - 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, (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, (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) } - } + 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}`"); + } + } + }, + default_refresh: default_refresh + Duration::from_secs(1), + whitelist_refresh: whitelist_refresh + Duration::from_secs(1) + }) + } + + 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, (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, (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 { self.default_theme.clone() } + } + pub fn handlebars(&self) -> &Handlebars { &self.handlebars } + pub fn default_theme(&self) -> Arc { self.default_theme.clone() } } -- cgit v1.2.3-54-g00ecf