add debug for lastfm

Author: Sanae6

.kube/deployment.yaml

@@ -17,6 +17,9 @@ spec:
       - name: personal-api
         image: kokuzo.tailc38f.ts.net/personal-api:latest
         imagePullPolicy: "Always"
+        env:
+        - name: RUST_LOG
+          value: "debug"
         ports:
         - containerPort: 3000
         args:

src/config.rs

@@ -1,6 +1,9 @@
 use std::{borrow::Cow, collections::HashMap};
 
-use axum_extra::{headers::{authorization::Bearer, Authorization}, TypedHeader};
+use axum_extra::{
+  TypedHeader,
+  headers::{Authorization, authorization::Bearer},
+};
 use serde::{Deserialize, Serialize};
 use steam_rs::steam_id::SteamId;
 
@@ -36,13 +39,16 @@ pub struct AuthConfig {
   pub scopes: Vec<String>,
 }
 
-pub fn scopes_from_bearer(bearer: Option<TypedHeader<Authorization<Bearer>>>, config: &'static Config) -> Cow<'static, [String]> {
+pub fn scopes_from_bearer(
+  bearer: Option<TypedHeader<Authorization<Bearer>>>,
+  config: &'static Config,
+) -> Cow<'static, [String]> {
   bearer
     .and_then(|auth| config.auth.get(auth.0.token()))
     .map(|auth| Cow::<'static, [String]>::Borrowed(&auth.scopes))
     .unwrap_or_default()
 }
 
-pub fn has_scope(auth_scopes: &Cow<[String]>, scope: &'static str) -> bool{
+pub fn has_scope(auth_scopes: &Cow<[String]>, scope: &'static str) -> bool {
   auth_scopes.iter().any(|s| scope == s)
 }

src/fetchers/icloud.rs

@@ -36,7 +36,7 @@ struct DeviceInfo {
 static DEVICE_INFO: LazyLock<RwLock<HashMap<String, DeviceInfo>>> = LazyLock::new(RwLock::default);
 static FINDER: LazyLock<DefaultFinder> = LazyLock::new(DefaultFinder::new);
 
-pub fn get_user_info(device_id: &str, auth_scopes: Cow<'static, [String]>) -> Option<Location> {
+pub fn get_user_info(device_id: &str, auth_scopes: &Cow<'static, [String]>) -> Option<Location> {
   DEVICE_INFO
     .read()
     .unwrap()

src/fetchers/last_fm.rs

@@ -1,21 +1,19 @@
-use std::{
-  collections::HashMap,
-  sync::{LazyLock, RwLock},
-  time::Duration,
-};
+use std::{borrow::Cow, collections::HashMap, sync::LazyLock, time::Duration};
 
-use chrono::{DateTime, SubsecRound, Utc};
-use futures::{FutureExt, TryFutureExt, future::join_all};
+use chrono::{DateTime, Local, SubsecRound, Utc};
+use futures::TryFutureExt;
 use lastfm::{
   artist::Artist,
   imageset::ImageSet,
   track::{NowPlayingTrack, Track},
 };
 use reqwest::Response;
 use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+use tracing::debug;
 use ts_rs::TS;
 
-use crate::config::Config;
+use crate::config::{Config, has_scope};
 
 #[allow(unused)]
 #[derive(Clone, Serialize, TS)]
@@ -64,14 +62,23 @@ impl PartialEq<NowPlayingTrack> for TypescriptTrack {
 #[ts(rename = "LastFmUserInfo")]
 pub struct UserInfo {
   username: String,
+  last_song_time: Option<DateTime<Local>>,
   currently_playing: Option<TypescriptTrack>,
 }
 
-static PLAYING_TRACKS: LazyLock<RwLock<HashMap<String, UserInfo>>> =
-  LazyLock::new(Default::default);
-
-pub fn fetch_lastfm_info(username: &str) -> Option<UserInfo> {
-  PLAYING_TRACKS.read().unwrap().get(username).cloned()
+static PLAYING_TRACKS: LazyLock<Mutex<HashMap<String, UserInfo>>> = LazyLock::new(Default::default);
+
+pub fn fetch_lastfm_info(username: &str, auth_scopes: &Cow<'static, [String]>) -> Option<UserInfo> {
+  PLAYING_TRACKS
+    .blocking_lock()
+    .get(username)
+    .cloned()
+    .map(|mut user| {
+      user
+        .last_song_time
+        .take_if(|_| !has_scope(&auth_scopes, "lastfm.lasttime"));
+      user
+    })
 }
 
 struct User {
@@ -83,7 +90,7 @@ pub async fn run(config: &'static Config) {
     return;
   };
 
-  *PLAYING_TRACKS.write().unwrap() = config
+  *PLAYING_TRACKS.lock().await = config
     .users
     .values()
     .filter_map(|config| {
@@ -92,6 +99,7 @@ pub async fn run(config: &'static Config) {
         last_fm_username.to_owned(),
         UserInfo {
           username: last_fm_username,
+          last_song_time: None,
           currently_playing: None,
           // currently_playing_recorded: None,
         },
@@ -112,20 +120,16 @@ pub async fn run(config: &'static Config) {
     .collect::<Vec<_>>();
 
   let perform_update = async move || {
-    join_all(
-      users
-        .iter()
-        .map(|user| update_currently_listening(&user.username, &last_fm_key)),
-    )
-    .map(drop)
-    .await;
+    for user in &users {
+      update_currently_listening(&user.username, &last_fm_key).await;
+    }
   };
 
   perform_update().await;
 
   tokio::spawn(async move {
     loop {
-      tokio::time::sleep(Duration::from_secs(10)).await;
+      tokio::time::sleep(Duration::from_secs(15)).await;
       perform_update().await
     }
   });
@@ -152,11 +156,12 @@ pub async fn update_currently_listening(username: &str, api_key: &str) {
     Ok(response) => {
       let currently_playing = response.recent_tracks.track.into_iter().find_map(|track| {
         let Track::NowPlaying(now_playing) = track else {
+          debug!("{username} is not listening to music");
           return None;
         };
         Some(now_playing)
       });
-      let mut users = PLAYING_TRACKS.write().unwrap();
+      let mut users = PLAYING_TRACKS.lock().await;
       if let Some(user) = users.get_mut(username) {
         user.currently_playing = currently_playing.map(|track| {
           let start_time = user
@@ -175,6 +180,7 @@ pub async fn update_currently_listening(username: &str, api_key: &str) {
             image: track.image,
           }
         });
+        user.last_song_time = Some(Local::now());
       }
     }
     Err(error) => {

src/fetchers/mod.rs

@@ -1,4 +1,4 @@
 pub mod discord;
+pub mod icloud;
 pub mod last_fm;
 pub mod steam;
-pub mod icloud;

src/main.rs

@@ -12,6 +12,7 @@ use routes::{
   get_host_user::get_host_user, get_user::get_user, get_users::get_users, root::root_page,
 };
 use tower::Layer;
+use tracing::debug;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -22,6 +23,8 @@ async fn main() -> anyhow::Result<()> {
   let config = read_to_string(config_arg).expect("failed to read config");
   let config = &*Box::leak(toml::from_str(&config).expect("failed to parse config"));
 
+  debug!("starting up fetchers");
+
   fetchers::discord::run_discord_bot(&config).await?;
   fetchers::last_fm::run(&config).await;
   fetchers::steam::run(&config).await;

src/routes/get_host_user.rs

@@ -3,7 +3,11 @@ use axum::{
   extract::{Path, State},
   response::Response,
 };
-use axum_extra::{extract::Host, headers::{authorization::Bearer, Authorization}, TypedHeader};
+use axum_extra::{
+  TypedHeader,
+  extract::Host,
+  headers::{Authorization, authorization::Bearer},
+};
 
 use crate::host_config::HandlerConfig;
 
@@ -25,7 +29,7 @@ pub async fn get_host_user(
         .cloned()
         .unwrap_or_default(),
     ),
-    auth
+    auth,
   )
   .await
 }

src/routes/get_user.rs

@@ -44,7 +44,7 @@ pub async fn get_user(
     .icloud_device_id
     .as_ref()
     .map(String::as_str)
-    .and_then(|id| icloud::get_user_info(id, auth_scopes));
+    .and_then(|id| icloud::get_user_info(id, &auth_scopes));
 
   Json(UserAggregate {
     name: &user.name,
@@ -59,7 +59,7 @@ pub async fn get_user(
       .last_fm_username
       .as_ref()
       .map(String::as_str)
-      .and_then(last_fm::fetch_lastfm_info),
+      .and_then(|username| last_fm::fetch_lastfm_info(username, &auth_scopes)),
     steam: user.steam_id.and_then(steam::get_user_info),
     location,
   })