update mihomo stuff so failed requests don't cause errors

only actual errors like parsing errors will be reported, any failed request due to rate limit or otherwise will just log a warning and return None.

Author: Js41637

src/api/mihomo/uid/mod.rs

@@ -37,7 +37,9 @@ async fn get_mihomo(
     language_params: web::Query<LanguageParams>,
     pool: web::Data<PgPool>,
 ) -> ApiResult<impl Responder> {
-    let json = mihomo::get(*uid, language_params.lang, &pool).await?;
+    let Some(json) = mihomo::get(*uid, language_params.lang, &pool).await? else {
+        return Ok(HttpResponse::InternalServerError().body("mihomo data unavailable"));
+    };
 
     Ok(HttpResponse::Ok().json(json))
 }
@@ -59,7 +61,9 @@ async fn put_mihomo(
 ) -> ApiResult<impl Responder> {
     let uid = *uid;
 
-    let json = mihomo::update_and_get(uid, language_params.lang, &pool).await?;
+    let Some(json) = mihomo::update_and_get(uid, language_params.lang, &pool).await? else {
+        return Ok(HttpResponse::InternalServerError().body("mihomo data unavailable"));
+    };
 
     Ok(HttpResponse::Ok().json(json))
 }

src/api/pages/leaderboard/uid/mod.rs

@@ -42,7 +42,7 @@ async fn get_leaderboard_entry(
 
     // Wacky way to update the database in case the uid isn't in there
     if !database::mihomo::exists(uid, &pool).await?
-        && mihomo::get(uid, Language::En, &pool).await.is_err()
+        && mihomo::get(uid, Language::En, &pool).await?.is_none()
     {
         let region = match uid.to_string().chars().next() {
             Some('6') => "na",

src/api/pages/profiles/uid/mod.rs

@@ -134,7 +134,9 @@ async fn get_profile(
         return Ok(HttpResponse::Forbidden().finish());
     }
 
-    let profile = get_profile_json(false, uid, language_params.lang, &pool).await?;
+    let Some(profile) = get_profile_json(false, uid, language_params.lang, &pool).await? else {
+        return Ok(HttpResponse::InternalServerError().body("failed fetching profile data"));
+    };
 
     Ok(HttpResponse::Ok().json(profile))
 }
@@ -177,7 +179,9 @@ async fn update_profile(
         return Ok(HttpResponse::Forbidden().finish());
     }
 
-    let profile = get_profile_json(true, uid, language_params.lang, &pool).await?;
+    let Some(profile) = get_profile_json(true, uid, language_params.lang, &pool).await? else {
+        return Ok(HttpResponse::InternalServerError().body("failed fetching profile data"));
+    };
 
     Ok(HttpResponse::Ok().json(profile))
 }
@@ -187,11 +191,14 @@ async fn get_profile_json(
     uid: i32,
     lang: Language,
     pool: &PgPool,
-) -> ApiResult<Profile> {
-    let mihomo = if update {
+) -> ApiResult<Option<Profile>> {
+    let Some(mihomo) = (if update {
         mihomo::update_and_get(uid, lang, pool).await?
     } else {
         mihomo::get(uid, lang, pool).await?
+    })
+    else {
+        return Ok(None);
     };
 
     let score_achievement = database::achievement_scores::get_by_uid(uid, pool).await?;
@@ -243,5 +250,5 @@ async fn get_profile_json(
         collection,
     };
 
-    Ok(profile)
+    Ok(Some(profile))
 }

src/api/pom_warps_import/uid/mod.rs

@@ -92,7 +92,7 @@ async fn post_pom_warps_import(
 
     // Wacky way to update the database in case the uid isn't in there
     if !database::mihomo::exists(uid, &pool).await?
-        && mihomo::get(uid, Language::En, &pool).await.is_err()
+        && mihomo::get(uid, Language::En, &pool).await?.is_none()
     {
         let region = match uid.to_string().chars().next() {
             Some('6') => "na",

src/api/scores/achievements/uid/mod.rs

@@ -58,7 +58,7 @@ async fn put_score_achievement(
     language_param: web::Query<LanguageParams>,
     pool: web::Data<PgPool>,
 ) -> ApiResult<impl Responder> {
-    mihomo::update_and_get(*uid, language_param.lang, &pool).await?;
+    let _ = mihomo::update_and_get(*uid, language_param.lang, &pool).await?;
 
     let score: ScoreAchievement = database::achievement_scores::get_by_uid(*uid, &pool)
         .await?

src/api/srgf_warps_import/mod.rs

@@ -98,7 +98,7 @@ async fn post_srgf_warps_import(
 
     // Wacky way to update the database in case the uid isn't in there
     if !database::mihomo::exists(uid, &pool).await?
-        && mihomo::get(uid, Language::En, &pool).await.is_err()
+        && mihomo::get(uid, Language::En, &pool).await?.is_none()
     {
         let region = match uid.to_string().chars().next() {
             Some('6') => "na",

src/api/srs_warps_import/uid/mod.rs

@@ -86,7 +86,7 @@ async fn post_srs_warps_import(
 
     // Wacky way to update the database in case the uid isn't in there
     if !database::mihomo::exists(uid, &pool).await?
-        && mihomo::get(uid, Language::En, &pool).await.is_err()
+        && mihomo::get(uid, Language::En, &pool).await?.is_none()
     {
         let region = match uid.to_string().chars().next() {
             Some('6') => "na",

src/api/users/me/uids/uid/mod.rs

@@ -67,7 +67,7 @@ async fn put_user_uid(
 
     // Wacky way to update the database in case the uid isn't in there
     if !database::mihomo::exists(uid, &pool).await?
-        && mihomo::get(uid, Language::En, &pool).await.is_err()
+        && mihomo::get(uid, Language::En, &pool).await?.is_none()
     {
         let region = match uid.to_string().chars().next() {
             Some('6') => "na",

src/api/warps_import/mod.rs

@@ -155,7 +155,7 @@ async fn post_warps_import(
 
     // Wacky way to update the database in case the uid isn't in there
     if !database::mihomo::exists(uid, &pool).await?
-        && mihomo::get(uid, Language::En, &pool).await.is_err()
+        && mihomo::get(uid, Language::En, &pool).await?.is_none()
     {
         let region = match uid.to_string().chars().next() {
             Some('6') => "na",

src/mihomo.rs

@@ -7,7 +7,7 @@ use serde_json::Value;
 use sqlx::PgPool;
 use utoipa::ToSchema;
 
-use anyhow::{bail, Context, Result};
+use anyhow::{anyhow, Context, Result};
 
 use crate::{database, Language};
 
@@ -50,7 +50,7 @@ fn load_cached(language: &Language, uid: i32) -> Result<Option<Mihomo>> {
     }
 }
 
-async fn fetch_json(url: &str, uid: i32, language: Language, label: &str) -> Result<Value> {
+async fn fetch_json(url: &str, uid: i32, language: Language, label: &str) -> Result<Option<Value>> {
     let response = reqwest::get(url)
         .await
         .with_context(|| format!("{label} request failed for uid {uid} language {language}"))?;
@@ -67,18 +67,16 @@ async fn fetch_json(url: &str, uid: i32, language: Language, label: &str) -> Res
             label,
             "response was not successful"
         );
-        bail!(
-            "{label} request returned non-success status {status} for uid {uid} language {language}"
-        );
+        return Ok(None);
     }
 
     let text = response
         .text()
         .await
-        .with_context(|| format!("mihomo {label} body read failed for uid {uid} language {language}"))?;
+        .with_context(|| format!("{label} response text retrieval failed for uid {uid} language {language}"))?;
 
     match serde_json::from_str(&text) {
-        Ok(json) => Ok(json),
+        Ok(json) => Ok(Some(json)),
         Err(err) => {
             warn!(
                 uid,
@@ -90,16 +88,14 @@ async fn fetch_json(url: &str, uid: i32, language: Language, label: &str) -> Res
                 error = %err,
                 "response decode failed"
             );
-            Err(err).with_context(|| {
-                format!(
-                    "{label} json decode failed for uid {uid} language {language} status {status}"
-                )
+            Err(anyhow!("mihomo response body parsing failed")).with_context(|| {
+                format!("{label} json decode failed for uid {uid} language {language}")
             })
         }
     }
 }
 
-pub async fn get(uid: i32, language: Language, pool: &PgPool) -> Result<Value> {
+pub async fn get(uid: i32, language: Language, pool: &PgPool) -> Result<Option<Value>> {
     let path = cache_path(&language, uid);
 
     if PathBuf::from(&path).exists() {
@@ -119,30 +115,27 @@ pub async fn get(uid: i32, language: Language, pool: &PgPool) -> Result<Value> {
         if should_update {
             update_and_get(uid, language, pool).await
         } else {
-            Ok(cached_json)
+            Ok(Some(cached_json))
         }
     } else {
         update_and_get(uid, language, pool).await
     }
 }
 
-pub async fn update_and_get(uid: i32, language: Language, pool: &PgPool) -> Result<Value> {
+pub async fn update_and_get(uid: i32, language: Language, pool: &PgPool) -> Result<Option<Value>> {
     let now = Utc::now();
     debug!(uid, language = %language, "mihomo update_and_get start");
 
     let url = format!(
         "https://api.mihomo.me/sr_info_parsed/{uid}?lang={}&version=v2",
         language.mihomo()
     );
-    debug!(uid, language = %language, url = %url, "fetching mihomo payload");
 
-    let mut json: Value = match fetch_json(&url, uid, language, "localized").await {
-        Ok(json) => json,
-        Err(err) => {
-            warn!(uid, language = %language, url = %url, error = %err, "mihomo localized fetch failed");
-            return Err(err);
-        }
+    let mut json = match fetch_json(&url, uid, language, "localized").await? {
+        Some(json) => json,
+        None => return Ok(None),
     };
+
     debug!(uid, language = %language, "fetched mihomo payload");
     if let Some(o) = json.as_object_mut() {
         o.insert("updated_at".to_string(), serde_json::to_value(now)?);
@@ -155,13 +148,11 @@ pub async fn update_and_get(uid: i32, language: Language, pool: &PgPool) -> Resu
         let en_url = format!("https://api.mihomo.me/sr_info_parsed/{uid}?lang=en&version=v2",);
         debug!(uid, language = %language, url = %en_url, "fetching english mihomo payload");
 
-        let mut en_json: Value = match fetch_json(&en_url, uid, language, "english").await {
-            Ok(json) => json,
-            Err(err) => {
-                warn!(uid, language = %language, url = %en_url, error = %err, "mihomo english fetch failed");
-                return Err(err);
-            }
+        let mut en_json = match fetch_json(&en_url, uid, language, "english").await? {
+            Some(json) => json,
+            None => return Ok(None),
         };
+
         debug!(uid, language = %language, "fetched english mihomo payload");
         if let Some(o) = en_json.as_object_mut() {
             o.insert("updated_at".to_string(), serde_json::to_value(now)?);
@@ -252,5 +243,5 @@ pub async fn update_and_get(uid: i32, language: Language, pool: &PgPool) -> Resu
     database::achievement_scores::set(&db_score_achievement, pool).await?;
     debug!(uid, language = %language, timestamp = %timestamp, "mihomo update_and_get complete");
 
-    Ok(json)
+    Ok(Some(json))
 }