feat: add try_get_scrobble method

This allows us to immediately return cached scrobbles in the rendered
HTML if available, but never waste any time waiting for the last.fm API
to give us new data if the cache is stale. The 200ms timeout that was
previously in place was never long enough for the last.fm API to return
so it was just an unnecessary delay on response times.

server/src/index.rs

···
 use crate::{scrobble::ScrobblesTemplate, scrobble_monitor::ScrobbleMonitor};
 
-use std::time::Duration;
-
 use askama::Template;
 
 #[derive(Template, Debug, Clone)]
···
 }
 
 pub async fn get_index(mut monitor: ScrobbleMonitor) -> RootTemplate {
-    let scrobbles_template = tokio::time::timeout(
-        Duration::from_millis(200),
-        tokio::spawn(async move { monitor.get_scrobble().await }),
-    )
-    .await;
+    let scrobbles_template = monitor.try_get_scrobble();
+    if scrobbles_template.is_none() {
+        // start fetching scrobble so we can send a fresh response to the client ASAP
+        tokio::spawn(async move { monitor.get_scrobble().await });
+    }
 
     RootTemplate {
-        scrobble: scrobbles_template
-            .map_err(|_| tracing::debug!("last.fm request took too long"))
-            .and_then(|scrobble| {
-                scrobble
-                    .map_err(|err| tracing::error!(?err, "Panicked when trying to get scrobble"))
-            })
-            .and_then(|scrobble| {
-                scrobble.map_err(|err| tracing::warn!(?err, "Failed to get scrobble"))
-            })
-            .ok(),
+        scrobble: scrobbles_template,
     }
 }

server/src/scrobble_monitor.rs

···
     fetch_time: Instant,
 }
 
+impl CachedScrobble {
+    fn is_fresh(&self) -> bool {
+        self.fetch_time.elapsed() < Duration::from_secs(30)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ScrobbleMonitor {
     client: Client,
···
         }
     }
 
-    pub async fn get_scrobble(&mut self) -> anyhow::Result<ScrobblesTemplate> {
-        let is_fresh = |fetch_time: &Instant| fetch_time.elapsed() < Duration::from_secs(30);
+    pub fn try_get_scrobble(&self) -> Option<ScrobblesTemplate> {
+        let scrobble = &*self.last_scrobble.try_read().ok()?;
+        scrobble
+            .as_ref()
+            .filter(|scrobble| scrobble.is_fresh())
+            .map(|scrobble| scrobble.data.clone())
+    }
 
+    pub async fn get_scrobble(&mut self) -> anyhow::Result<ScrobblesTemplate> {
         if let Some(scrobble) = &*self.last_scrobble.read().await {
-            if is_fresh(&scrobble.fetch_time) {
+            if scrobble.is_fresh() {
                 tracing::debug!("returning recently fetched scrobble data");
                 return Ok(scrobble.data.clone());
             }
···
         match &*last_scrobble {
             // make sure another task hasn't fetched the new data first after we
             // both waited for write access
-            Some(scrobble) if is_fresh(&scrobble.fetch_time) => {
+            Some(scrobble) if scrobble.is_fresh() => {
                 tracing::debug!("returning (very) recently fetched scrobble data");
                 Ok(scrobble.data.clone())
             }