Upload main.rs

src/main.rs

@@ -40,6 +40,13 @@ struct ArlSession {
 }
 
 #[derive(Clone)]
+struct CdnCacheEntry {
+    cdn_url: String,
+    decrypt_id: u64,
+    format: String,
+    expires_at: std::time::Instant,
+}
+
 struct AppState {
     api: Arc<Mutex<APIClient>>,
     api_by_arl: Arc<RwLock<HashMap<String, Arc<Mutex<APIClient>>>>>,
@@ -47,6 +54,8 @@ struct AppState {
     pair: Arc<RwLock<HashMap<String, PairSession>>>,
     pair_store_path: String,
     arl_store_path: String,
+    /// CDN URL кэш для предзагрузки. Ключ: track_id. TTL 20 мин.
+    cdn_cache: Arc<RwLock<HashMap<u64, CdnCacheEntry>>>,
 }
 
 fn license_token_from_ud(ud: &serde_json::Value) -> String {
@@ -1117,12 +1126,15 @@ async fn download(
         .into_response()
 }
 
-async fn stream(
+/// /warm — прогревает CDN URL кэш для трека.
+/// Render вызывает этот эндпоинт ПЕРЕД отправкой sendAudio,
+/// чтобы к моменту Telegram-запроса кэш уже был горячим.
+async fn warm(
     State(state): State<AppState>,
     Query(q): Query<StreamParams>,
-    headers: HeaderMap,
 ) -> impl IntoResponse {
-    let formats = match q.format.as_deref().unwrap_or("AUTO") {
+    let fmt_str = q.format.as_deref().unwrap_or("AUTO");
+    let formats = match fmt_str {
         "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],
@@ -1132,82 +1144,199 @@ async fn stream(
 
     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;
+        .filter(|s| !s.is_empty())
+        .or_else(|| std::env::var("DEEZER_ARL").ok().filter(|s| !s.is_empty()));
 
     if arl_key.is_none() {
-        tracing::error!("stream {}: arl missing", q.id);
-        return (StatusCode::SERVICE_UNAVAILABLE, "arl required").into_response();
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "arl required");
     }
 
+    // Проверяем — может уже в кэше есть свежая запись
+    {
+        let cache = state.cdn_cache.read().await;
+        if let Some(e) = cache.get(&q.id) {
+            if e.expires_at > std::time::Instant::now() {
+                tracing::debug!("warm {}: already cached", q.id);
+                return (StatusCode::OK, Json(json!({ "ok": true, "cached": true }))).into_response();
+            }
+        }
+    }
+
+    // Resolve fallback_id
     let client = api_client_for_arl(&state, arl_key.clone()).await;
     let target_id = {
         let mut c = client.lock().await;
         resolve_fallback_id(&mut c, q.id).await
     };
     let mut decrypt_id = target_id;
+    let mut url: Option<String> = None;
 
-    // Try DZMEDIA_UPSTREAM first — gives highest available quality (FLAC/320)
-    // We already have correct decrypt_id from ARL above, so decryption will be correct
-    if url.is_none() {
-        if let Ok(text) = upstream_get_url_text(&formats, &vec![target_id]).await {
-            if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
-                let format_strings: Vec<String> = formats.iter().map(|f| format!("{:?}", f)).collect();
-                let format_strs: Vec<&str> = format_strings.iter().map(|s| s.as_str()).collect();
-                let (u, _, _) = extract_media_url_and_format(&v, &format_strs);
-                if !u.is_empty() {
-                    url = Some(u);
-                }
-            }
+    // Try upstream first
+    if let Ok(text) = upstream_get_url_text(&formats, &vec![target_id]).await {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
+            let fstrs: Vec<String> = formats.iter().map(|f| format!("{:?}", f)).collect();
+            let fstrs_ref: Vec<&str> = fstrs.iter().map(|s| s.as_str()).collect();
+            let (u, _, _) = extract_media_url_and_format(&v, &fstrs_ref);
+            if !u.is_empty() { url = Some(u); }
         }
     }
 
-    // Fallback: use ARL to get CDN URL via Deezer API (quality limited by account tier)
+    // Fallback: ARL
     for attempt in 0..2u8 {
         if url.is_some() { break; }
-
         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();
-            }
+            if let Some(ref arl) = arl_key { state.api_by_arl.write().await.remove(arl); }
         }
-
         let client = api_client_for_arl(&state, arl_key.clone()).await;
         let res = {
             let mut c = client.lock().await;
             if attempt >= 1 {
-                if let Err(e) = c.force_renew().await {
-                    last_err = Some(format!("renew:{}", e));
-                    continue;
-                }
+                if let Err(_) = c.force_renew().await { continue; }
             }
-            match timeout(Duration::from_secs(12), media_url_for_track(&mut c, target_id, &formats)).await {
+            match timeout(Duration::from_secs(15), media_url_for_track(&mut c, target_id, &formats)).await {
                 Ok(v) => v,
                 Err(_) => Err("timeout".to_string()),
             }
         };
+        if let Ok((u, _, id_used)) = res { url = Some(u); decrypt_id = id_used; break; }
+    }
+
+    match url {
+        Some(u) => {
+            let mut cache = state.cdn_cache.write().await;
+            if cache.len() > 200 { cache.retain(|_, e| e.expires_at > std::time::Instant::now()); }
+            cache.insert(q.id, CdnCacheEntry {
+                cdn_url: u,
+                decrypt_id,
+                format: fmt_str.to_string(),
+                expires_at: std::time::Instant::now() + Duration::from_secs(20 * 60),
+            });
+            tracing::info!("warm {}: cached OK", q.id);
+            (StatusCode::OK, Json(json!({ "ok": true, "cached": false }))).into_response()
+        }
+        None => {
+            tracing::error!("warm {}: failed to get CDN URL", q.id);
+            json_error(StatusCode::NOT_FOUND, "track not found")
+        }
+    }
+}
 
-        match res {
-            Ok((u, _, id_used)) => { url = Some(u); decrypt_id = id_used; break; }
-            Err(e) => { last_err = Some(e); }
+async fn stream(
+    State(state): State<AppState>,
+    Query(q): Query<StreamParams>,
+    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],
+        "MP3_MISC" => vec![Format::MP3_MISC, Format::MP3_128],
+        "MP3_128"  => vec![Format::MP3_128],
+        _          => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+    };
+
+    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 decrypt_id: u64 = q.id; // overwritten after resolve_fallback_id
+    let mut last_err: Option<String> = None;
+
+    if arl_key.is_none() {
+        tracing::error!("stream {}: arl missing", q.id);
+        return (StatusCode::SERVICE_UNAVAILABLE, "arl required").into_response();
+    }
+
+    // ── CDN кэш: если есть свежая запись — пропускаем все Deezer API вызовы ──
+    {
+        let cache = state.cdn_cache.read().await;
+        if let Some(e) = cache.get(&q.id) {
+            if e.expires_at > std::time::Instant::now() {
+                tracing::debug!("stream {}: CDN cache hit ({})", q.id, e.format);
+                url = Some(e.cdn_url.clone());
+                decrypt_id = e.decrypt_id;
+            }
         }
     }
 
+    if url.is_none() {
+        // Resolve fallback_id for proper decryption key
+        let client = api_client_for_arl(&state, arl_key.clone()).await;
+        let target_id = {
+            let mut c = client.lock().await;
+            resolve_fallback_id(&mut c, q.id).await
+        };
+        decrypt_id = target_id;
+
+        // Try DZMEDIA_UPSTREAM first — gives highest available quality (FLAC/320)
+        if url.is_none() {
+            if let Ok(text) = upstream_get_url_text(&formats, &vec![target_id]).await {
+                if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
+                    let format_strings: Vec<String> = formats.iter().map(|f| format!("{:?}", f)).collect();
+                    let format_strs: Vec<&str> = format_strings.iter().map(|s| s.as_str()).collect();
+                    let (u, _, _) = extract_media_url_and_format(&v, &format_strs);
+                    if !u.is_empty() {
+                        url = Some(u);
+                    }
+                }
+            }
+        }
+
+        // Fallback: use ARL to get CDN URL via Deezer API
+        for attempt in 0..2u8 {
+            if url.is_some() { break; }
+            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 c = client.lock().await;
+                if attempt >= 1 {
+                    if let Err(e) = c.force_renew().await {
+                        last_err = Some(format!("renew:{}", e));
+                        continue;
+                    }
+                }
+                match timeout(Duration::from_secs(12), media_url_for_track(&mut c, target_id, &formats)).await {
+                    Ok(v) => v,
+                    Err(_) => Err("timeout".to_string()),
+                }
+            };
+            match res {
+                Ok((u, fmt, id_used)) => { url = Some(u); decrypt_id = id_used; let _ = fmt; break; }
+                Err(e) => { last_err = Some(e); }
+            }
+        }
+
+        // ── Пишем в кэш если удалось получить URL ──
+        if let Some(ref u) = url {
+            let mut cache = state.cdn_cache.write().await;
+            if cache.len() > 200 {
+                cache.retain(|_, e| e.expires_at > std::time::Instant::now());
+            }
+            cache.insert(q.id, CdnCacheEntry {
+                cdn_url: u.clone(),
+                decrypt_id,
+                format: q.format.clone().unwrap_or_else(|| "AUTO".to_string()),
+                expires_at: std::time::Instant::now() + Duration::from_secs(20 * 60),
+            });
+        }
+    }
 
     let url = match url {
         Some(u) => u,
         None => {
             let err = last_err.unwrap_or_else(|| "stream:no_url".to_string());
             tracing::error!("stream {} failed: {}", q.id, err);
-            // Return 404 so the browser audio element gracefully fails without triggering demuxer errors
             return (StatusCode::NOT_FOUND, "Not Found").into_response();
         }
     };
 
+
     fn parse_range_header(v: &str) -> Option<(u64, Option<u64>)> {
         let v = v.trim();
         let v = v.strip_prefix("bytes=")?;
@@ -3644,6 +3773,7 @@ async fn main() {
         pair: Arc::new(RwLock::new(HashMap::new())),
         pair_store_path: std::env::var("PAIR_STORE_PATH").ok().unwrap_or_else(|| "pair_store.json".to_string()),
         arl_store_path: std::env::var("ARL_STORE_PATH").ok().unwrap_or_else(|| "arl_store.json".to_string()),
+        cdn_cache: Arc::new(RwLock::new(HashMap::new())),
     };
     arl_store_load(&state).await;
     pair_store_load(&state).await;
@@ -3662,6 +3792,7 @@ async fn main() {
         .route("/stream", get(stream))
         .route("/download", get(download))
         .route("/send_audio", get(send_audio))
+        .route("/warm", get(warm))
         .route("/stream_info", get(stream_info))
         .route("/user_data", post(user_data))
         .route("/playlists", post(playlists))