Upload 2 files

src/api.rs

@@ -174,14 +174,38 @@ impl APIClient {
         self.no_renew_api_call(method, params).await
     }
 
+    /// Принудительное обновление токенов — вызывается при ошибках стрима
+    pub async fn force_renew(&mut self) -> Result<(), APIError> {
+        self.renew_instant = None; // сбрасываем таймер
+        self.renew().await
+    }
+
     async fn renew(&mut self) -> Result<(), APIError> {
         let user_data: serde_json::Value = self.user_data().await?;
 
-        self.check_form = user_data["checkForm"].as_str().unwrap().to_string();
-        self.license_token = user_data["USER"]["OPTIONS"]["license_token"].as_str().unwrap().to_string();
+        let check_form = user_data["checkForm"].as_str().unwrap_or("").to_string();
+        let license_token = user_data
+            .pointer("/USER/OPTIONS/license_token")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .to_string();
+
+        if check_form.is_empty() {
+            return Err(APIError::DeezerError {
+                code: "renew".to_string(),
+                message: "checkForm missing in getUserData response".to_string(),
+            });
+        }
+        if license_token.is_empty() {
+            return Err(APIError::DeezerError {
+                code: "renew".to_string(),
+                message: "license_token missing in getUserData response".to_string(),
+            });
+        }
 
+        self.check_form    = check_form;
+        self.license_token = license_token;
         self.renew_instant = Some(Instant::now());
-
         Ok(())
     }
 

src/main.rs

@@ -176,10 +176,9 @@ async fn media_url_for_track(
 fn upstream_dzmedia_base() -> Option<String> {
     let env = std::env::var("DZMEDIA_UPSTREAM").ok().unwrap_or_default();
     let base = env.trim();
-    if base.is_empty() {
-        return Some("https://lufts-dzmedia.fly.dev".to_string());
-    }
-    if base == "-" {
+    // Если переменная не задана — upstream отключён (используем только ARL)
+    // Чтобы включить upstream — задайте DZMEDIA_UPSTREAM=https://your-instance.fly.dev
+    if base.is_empty() || base == "-" {
         return None;
     }
     Some(base.trim_end_matches('/').to_string())
@@ -389,63 +388,58 @@ struct StreamParams {
 
 async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams>) -> impl IntoResponse {
     let formats = match q.format.as_deref().unwrap_or("AUTO") {
-        "FLAC" => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
-        "MP3_320" => vec![Format::MP3_320, Format::MP3_128],
+        "FLAC"     => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+        "MP3_320"  => vec![Format::MP3_320, Format::MP3_128],
         "MP3_MISC" => vec![Format::MP3_MISC, Format::MP3_128],
-        "MP3_128" => vec![Format::MP3_128],
-        "AUTO" | _ => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+        "MP3_128"  => vec![Format::MP3_128],
+        _          => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
     };
 
     let requested = q.format.clone().unwrap_or_else(|| "AUTO".to_string());
-    let mut url: String = String::new();
+    let mut url: String  = String::new();
     let mut used: String = String::new();
     let mut last_err: Option<String> = None;
 
+    // Upstream (опционально — если DZMEDIA_UPSTREAM задан)
     if let Ok(text) = upstream_get_url_text(&formats, &vec![q.id]).await {
         if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
-            url = extract_media_url(&v);
+            url  = extract_media_url(&v);
             used = extract_media_format(&v);
         }
     }
 
+    // ARL путь — до 2 попыток
     if url.is_empty() {
         if let Some(arl) = q.arl.clone().filter(|s| !s.trim().is_empty()) {
-            let client = api_client_for_arl(&state, Some(arl)).await;
-            let res = async {
-                let mut client = client.lock().await;
-                let resp: Result<DeezerTrackList, APIError> = client
-                    .api_call(
-                        "song.getListData",
-                        &json!({"sng_ids":[q.id],"array_default":["SNG_ID","TRACK_TOKEN","DURATION"]}),
-                    )
-                    .await;
-                let track_list = resp.map_err(|e| e.to_string())?;
-                if track_list.data.is_empty() {
-                    return Err("No valid ID".to_string());
-                }
-                let track_token = track_list.data[0].TRACK_TOKEN.as_str();
-                let media_resp = client
-                    .get_media(&formats, vec![track_token])
-                    .await
-                    .map_err(|e| e.to_string())?;
-                let media_json: serde_json::Value = media_resp
-                    .json()
-                    .await
-                    .map_err(|_| "Bad media response".to_string())?;
-                let url = extract_media_url(&media_json);
-                let used = extract_media_format(&media_json);
-                if url.is_empty() {
-                    return Err("No url in media response".to_string());
+            'arl: for attempt in 0..2u8 {
+                if attempt == 1 {
+                    state.api_by_arl.write().await.remove(&arl);
                 }
-                Ok::<(String, String), String>((url, used))
-            }
-            .await;
-            match res {
-                Ok((u, f)) => {
-                    url = u;
-                    used = f;
+                let client = api_client_for_arl(&state, Some(arl.clone())).await;
+                let res = async {
+                    let mut c = client.lock().await;
+                    if attempt == 1 { let _ = c.force_renew().await; }
+                    let resp: Result<DeezerTrackList, APIError> = c
+                        .api_call(
+                            "song.getListData",
+                            &json!({"sng_ids":[q.id],"array_default":["SNG_ID","TRACK_TOKEN","DURATION"]}),
+                        )
+                        .await;
+                    let track_list = resp.map_err(|e| e.to_string())?;
+                    if track_list.data.is_empty() { return Err("No valid ID".to_string()); }
+                    let token = track_list.data[0].TRACK_TOKEN.as_str();
+                    let media_resp = c.get_media(&formats, vec![token]).await.map_err(|e| e.to_string())?;
+                    let media_json: serde_json::Value = media_resp.json().await
+                        .map_err(|_| "Bad media response".to_string())?;
+                    let u = extract_media_url(&media_json);
+                    let f = extract_media_format(&media_json);
+                    if u.is_empty() { return Err("No url in media response".to_string()); }
+                    Ok::<(String, String), String>((u, f))
+                }.await;
+                match res {
+                    Ok((u, f)) => { url = u; used = f; break 'arl; }
+                    Err(e)     => { last_err = Some(e); }
                 }
-                Err(e) => last_err = Some(e),
             }
         }
     }
@@ -475,37 +469,31 @@ async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams
         if let Some(ct) = r.headers().get(reqwest::header::CONTENT_TYPE).and_then(|v| v.to_str().ok()) {
             mime = ct.to_string();
         }
-        if let Some(cr) = r
-            .headers()
-            .get(reqwest::header::CONTENT_RANGE)
+        if let Some(cr) = r.headers().get(reqwest::header::CONTENT_RANGE)
             .and_then(|v| v.to_str().ok())
             .and_then(total_from_content_range)
         {
             total_bytes = cr;
-        } else if let Some(cl) = r.headers().get(reqwest::header::CONTENT_LENGTH).and_then(|v| v.to_str().ok()) {
+        } else if let Some(cl) = r.headers().get(reqwest::header::CONTENT_LENGTH)
+            .and_then(|v| v.to_str().ok())
+        {
             total_bytes = cl.parse::<u64>().unwrap_or(0);
         }
     }
 
     let bitrate_kbps = if duration > 0 && total_bytes > 0 {
         ((total_bytes as f64) * 8.0 / (duration as f64) / 1000.0).round() as u64
-    } else {
-        0
-    };
+    } else { 0 };
 
-    (
-        StatusCode::OK,
-        Json(json!({
-            "id": q.id,
-            "requested": requested,
-            "used": used,
-            "duration": duration,
-            "bytes": total_bytes,
-            "bitrate_kbps": bitrate_kbps,
-            "mime": mime
-        })),
-    )
-        .into_response()
+    (StatusCode::OK, Json(json!({
+        "id":          q.id,
+        "requested":   requested,
+        "used":        used,
+        "duration":    duration,
+        "bytes":       total_bytes,
+        "bitrate_kbps": bitrate_kbps,
+        "mime":        mime
+    }))).into_response()
 }
 
 async fn stream(
@@ -514,80 +502,66 @@ async fn stream(
     headers: HeaderMap,
 ) -> impl IntoResponse {
     let formats = match q.format.as_deref().unwrap_or("AUTO") {
-        "FLAC" => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
-        "MP3_320" => vec![Format::MP3_320, Format::MP3_128],
+        "FLAC"     => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+        "MP3_320"  => vec![Format::MP3_320, Format::MP3_128],
         "MP3_MISC" => vec![Format::MP3_MISC, Format::MP3_128],
-        "MP3_128" => vec![Format::MP3_128],
-        "AUTO" | _ => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+        "MP3_128"  => vec![Format::MP3_128],
+        _          => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
     };
 
-    let arl_key = q
-        .arl
-        .clone()
+    let arl_key = q.arl.clone()
         .map(|s| s.trim().to_string())
         .filter(|s| !s.is_empty());
 
     let mut url: Option<String> = None;
     let mut last_err: Option<String> = None;
 
+    // Если ARL не передан — пробуем upstream (может быть отключён)
     if arl_key.is_none() {
         match upstream_media_url(q.id, &formats).await {
-            Ok(u) => url = Some(u),
+            Ok(u)  => url = Some(u),
             Err(e) => last_err = Some(e),
         }
     }
 
-    for attempt in 0..2 {
-        if url.is_some() {
-            break;
+    // До 3 попыток: 0 — обычная, 1 — после сброса кэша клиента, 2 — принудительный renew внутри
+    for attempt in 0..3u8 {
+        if url.is_some() { break; }
+
+        // На попытке 1 — выбрасываем кэшированный клиент чтобы пересоздать его
+        if attempt == 1 {
+            if let Some(ref arl) = arl_key {
+                state.api_by_arl.write().await.remove(arl);
+            } else {
+                *state.api.lock().await = APIClient::new();
+            }
         }
+
         let client = api_client_for_arl(&state, arl_key.clone()).await;
         let res = {
-            let mut client = client.lock().await;
-            media_url_for_track(&mut client, q.id, &formats).await
+            let mut c = client.lock().await;
+            // На попытке 2 — принудительно обновляем токены перед запросом
+            if attempt == 2 {
+                if let Err(e) = c.force_renew().await {
+                    last_err = Some(format!("renew:{}", e));
+                    break;
+                }
+            }
+            media_url_for_track(&mut c, q.id, &formats).await
         };
 
         match res {
-            Ok(u) => {
-                url = Some(u);
-                break;
-            }
-            Err(e) => {
-                last_err = Some(e);
-                if attempt == 0 {
-                    if let Some(arl) = arl_key.clone() {
-                        let mut map = state.api_by_arl.write().await;
-                        map.remove(&arl);
-                    } else {
-                        let mut global = state.api.lock().await;
-                        *global = APIClient::new();
-                    }
-                }
-            }
+            Ok(u)  => { url = Some(u); break; }
+            Err(e) => { last_err = Some(e); }
         }
     }
 
     let url = match url {
         Some(u) => u,
-        None => {
-            if arl_key.is_some() {
-                if let Ok(u) = upstream_media_url(q.id, &formats).await {
-                    u
-                } else {
-                    return (
-                        StatusCode::SERVICE_UNAVAILABLE,
-                        last_err.unwrap_or_else(|| "stream:error".to_string()),
-                    )
-                        .into_response();
-                }
-            } else {
-                return (
-                    StatusCode::SERVICE_UNAVAILABLE,
-                    last_err.unwrap_or_else(|| "stream:error".to_string()),
-                )
-                    .into_response();
-            }
-        }
+        None => return (
+            StatusCode::SERVICE_UNAVAILABLE,
+            last_err.unwrap_or_else(|| "stream:no_url".to_string()),
+        ).into_response(),
     };
 
     fn parse_range_header(v: &str) -> Option<(u64, Option<u64>)> {