Custom font support complete

1 files changed, 61 insertions, 22 deletions

diff --git a/src/config.rs b/src/config.rs
index 4c5d4b7..8492f8b 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -20,18 +20,18 @@ pub static STATE: LazyLock<Arc<State>> = LazyLock::new(|| {
     State::new()
 });
 
-fn getter(username: &String) -> Pin<Box<(dyn Future<Output = Result<Arc<(User, Track)>, (StatusCode, &'static str)>> + Send + Sync)>> {
+fn user_getter(username: &String) -> Pin<Box<(dyn Future<Output = Result<Arc<(User, Track)>, (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.api_key))
+        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.api_key))
+
+        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!")); }
@@ -44,23 +44,55 @@ fn getter(username: &String) -> Pin<Box<(dyn Future<Output = Result<Arc<(User, T
         Ok(Arc::new((userinfo, tracksinfo)))
     })
 }
-type Getter = fn(&String) -> Pin<Box<(dyn Future<Output = Result<Arc<(User, Track)>, (StatusCode, &'static str)>> + Send + Sync)>>;
-type Cache = Arc<RwLock<AsyncCache<String, Arc<(User, Track)>, Getter>>>;
+
+fn font_getter(fontname: &String) -> Pin<Box<(dyn Future<Output = Result<Arc<str>, (StatusCode, &'static str)>> + Send + Sync)>> {
+  let fontname = urlencoding::encode(fontname.as_ref()).to_string();
+  Box::pin(async move {
+    let Some(google_api_key) = STATE.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))
+      .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!")); }
+    if fontreq.status() == StatusCode::FORBIDDEN {
+      log::error!("Invalid Google API key in config!");
+      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}"))
+      .send().await
+      .map_err(|e| {log::error!("Failed to get CSS for font `{fontname}`: {e}"); (StatusCode::SERVICE_UNAVAILABLE, "Couldn't download font CSS!")})?;
+
+    Ok(cssreq.text().await.unwrap().into())
+  })
+}
+
+type UserGetter = fn(&String) -> Pin<Box<(dyn Future<Output = Result<Arc<(User, Track)>, (StatusCode, &'static str)>> + Send + Sync)>>;
+type UserCache = Arc<RwLock<AsyncCache<String, Arc<(User, Track)>, UserGetter>>>;
+type FontGetter = fn(&String) -> Pin<Box<(dyn Future<Output = Result<Arc<str>, (StatusCode, &'static str)>> + Send + Sync)>>;
+type FontCache = Arc<RwLock<AsyncCache<String, Arc<str>, FontGetter>>>;
 #[derive(Debug)]
 enum Whitelist {
-    Exclusive{cache: Cache, whitelist: HashSet<String>},
-    Open{default_cache: Cache, whitelist_cache: Cache, whitelist: HashSet<String>}
+    Exclusive{cache: UserCache, whitelist: HashSet<String>},
+    Open{default_cache: UserCache, whitelist_cache: UserCache, whitelist: HashSet<String>}
 }
 #[derive(Debug)]
 pub struct State {
-    api_key: Arc<str>,
+    lastfm_api_key: Arc<str>,
+    google_api_key: Option<Arc<str>>,
     whitelist: Whitelist,
     port: u16,
+
     handlebars: Handlebars<'static>,
     default_theme: Arc<str>,
     send_refresh_header: bool,
     http: Client,
 
+    google_fonts_cache: FontCache,
+
     default_refresh: Duration,
     whitelist_refresh: Duration,
 }
@@ -68,33 +100,33 @@ pub struct State {
 impl State {
     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 cache_from_duration = |d: Duration| -> Cache {
-            Arc::new(RwLock::new(AsyncCache::new(d, getter as Getter)))
+        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 = cache_from_duration(default_refresh);
-        let whitelist_cache = cache_from_duration(whitelist_refresh);
+        let default_cache = user_cache_from_duration(default_refresh);
+        let whitelist_cache = user_cache_from_duration(whitelist_refresh);
 
         Arc::new(State {
-            api_key: var("LFME_API_KEY").expect("API key must be set").into(),
+            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();
@@ -103,14 +135,17 @@ impl State {
                 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<HashSet<String>> {
                     var("LFME_WHITELIST").ok().map(
-                        |w| w.split(",").map(|s| s.trim().to_string()).collect()                           
+                        |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()}
@@ -127,9 +162,13 @@ impl State {
             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<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)>, (StatusCode, &'static str)>, Duration) {
         match &self.whitelist {
             Whitelist::Open{default_cache, whitelist_cache, whitelist} => {