From 4bec6679a8af2a2b5cb53610a80dece3b6d30bb4 Mon Sep 17 00:00:00 2001 From: alyx Date: Thu, 10 Aug 2023 03:10:54 -0400 Subject: lots of stuff. theming basically done, added some logging, frontend basically done. --- src/config.rs | 96 +++++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 61 insertions(+), 35 deletions(-) (limited to 'src/config.rs') diff --git a/src/config.rs b/src/config.rs index bf02592..aad298f 100644 --- a/src/config.rs +++ b/src/config.rs @@ -1,12 +1,9 @@ use std::collections::{HashMap, HashSet}; -use std::error::Error; use std::sync::LazyLock; use std::sync::Arc; use std::future::Future; use std::pin::Pin; -use std::fs; use std::time::*; -use duration_str as ds; use super::cache::AsyncCache; use super::deserialize::{GetRecentTracks, GetUserInfo, Track, User}; @@ -14,6 +11,8 @@ use super::deserialize::{GetRecentTracks, GetUserInfo, Track, User}; use reqwest::{Client, StatusCode}; use dotenv::var; use tokio::sync::RwLock; +use handlebars::Handlebars; +use duration_str as ds; static INTERNAL_THEMES: &[(&'static str, &'static str)] = &[("plain", "")]; @@ -21,7 +20,7 @@ pub static STATE: LazyLock> = LazyLock::new(|| { State::new() }); -fn getter(username: &String) -> Pin>>> { +fn getter(username: &String) -> Pin, (StatusCode, &'static str)>> + Send + Sync)>> { let username = username.clone(); 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.api_key)) @@ -42,11 +41,11 @@ fn getter(username: &String) -> Pin Pin>)>>; -type Cache = Arc>>; +type Getter = fn(&String) -> Pin, (StatusCode, &'static str)>> + Send + Sync)>>; +type Cache = Arc, Getter>>>; #[derive(Debug)] enum Whitelist { Exclusive{cache: Cache, whitelist: HashSet}, @@ -57,44 +56,50 @@ pub struct State { api_key: Arc, whitelist: Whitelist, port: u16, - themes: HashMap>, + handlebars: Handlebars<'static>, + default_theme: Arc, send_refresh_header: bool, - http: Client + http: Client, + + 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 cache_from_duration = |d: Duration| -> Cache { + Arc::new(RwLock::new(AsyncCache::new(d, getter as Getter))) + }; + let default_refresh = duration_from_var("LFME_DEFAULT_REFRESH", 300); + let whitelist_refresh = duration_from_var("LFME_WHITELIST_REFRESH", 60); + let default_cache = cache_from_duration(default_refresh); + let whitelist_cache = cache_from_duration(whitelist_refresh); + Arc::new(State { api_key: var("LFME_API_KEY").expect("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_SET_HEADER").map(|h| &h == "1").unwrap_or(false), + 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(), - themes: { - if let Ok(themes_dir) = var("LFME_THEMES_DIR") { - INTERNAL_THEMES.iter().map(|(k, v)| (k.to_string(), (*v).into())).chain(fs::read_dir(themes_dir).expect("error reading LFME_THEMES_DIR") - .map(|a| a.expect("error reading LFME_THEMES_DIR")) - .filter_map(|a| { - let path = a.path(); - if fs::metadata(&path).map(|m| m.is_file()).unwrap_or(false) && - path.extension() == Some("css".as_ref()) { - Some((path.file_stem().unwrap().to_str().expect("bad filename").to_string(), fs::read_to_string(&path).expect("couldn't read theme CSS").into())) - } - else { None } - })) - .collect() + handlebars: { + let mut hb = Handlebars::new(); + for (key, fulltext) in INTERNAL_THEMES { + log::info!(target: "lfm::config::theme", "Registering internal theme `{key}`"); + hb.register_template_string(key, fulltext).unwrap(); } - else { HashMap::new() } + 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()), whitelist: { - let cache_from_var = |v: &str, d: u64| -> Cache { - let refresh = var(v).map(|r| ds::parse(&r).expect("bad duration string")).unwrap_or_else(|_| Duration::from_secs(d)); - Arc::new(RwLock::new(AsyncCache::new(refresh, getter as Getter) as AsyncCache)) - }; - let default_cache = || cache_from_var("LFME_DEFAULT_REFRESH", 300); - let whitelist_cache = || cache_from_var("LFME_WHITELIST_REFRESH", 60); - let load_whitelist = || -> Option> { var("LFME_WHITELIST").ok().map( |w| w.split(",").map(|s| s.trim().to_string()).collect() @@ -103,20 +108,41 @@ impl State { match var("LFME_WHITELIST_MODE").map(|m| m.to_ascii_lowercase()).unwrap_or_else(|_| "open".into()).as_str() { "open" => { - Whitelist::Open{default_cache: default_cache(), whitelist_cache: whitelist_cache(), whitelist: load_whitelist().unwrap_or_default()} + 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")} + 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(5), + whitelist_refresh: whitelist_refresh + Duration::from_secs(5) }) } pub fn port(&self) -> u16 { self.port } pub fn send_refresh_header(&self) -> bool { self.send_refresh_header } - pub fn get_theme(&self, theme: &str) -> Option> { self.themes.get(theme).cloned() } + 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() } } -- cgit v1.2.3-54-g00ecf