Upload 2 files

src/main.rs

@@ -30,7 +30,7 @@ type BoxErr = Box<dyn std::error::Error + Send + Sync + 'static>;
 mod api;
 use api::{APIClient, APIError, Format};
 
-#[derive(Clone)]
+#[derive(Clone, Serialize, Deserialize)]
 struct ArlSession {
     check_form: String,
     license_token: String,
@@ -43,6 +43,7 @@ struct AppState {
     arl_sessions: Arc<RwLock<HashMap<String, ArlSession>>>,
     pair: Arc<RwLock<HashMap<String, PairSession>>>,
     pair_store_path: String,
+    arl_store_path: String,
 }
 
 fn license_token_from_ud(ud: &serde_json::Value) -> String {
@@ -68,6 +69,32 @@ async fn store_arl_session(state: &AppState, arl: &str, check_form: &str, licens
             license_token: license_token.to_string(),
         },
     );
+    arl_store_save(state).await;
+}
+
+async fn arl_store_save(state: &AppState) {
+    let path = state.arl_store_path.trim();
+    if path.is_empty() {
+        return;
+    }
+    let map = state.arl_sessions.read().await.clone();
+    let Ok(txt) = serde_json::to_string(&map) else { return };
+    let tmp = format!("{path}.tmp");
+    if tokio::fs::write(&tmp, txt).await.is_ok() {
+        let _ = tokio::fs::rename(&tmp, path).await;
+    }
+}
+
+async fn arl_store_load(state: &AppState) {
+    let path = state.arl_store_path.trim();
+    if path.is_empty() {
+        return;
+    }
+    if let Ok(txt) = tokio::fs::read_to_string(path).await {
+        if let Ok(map) = serde_json::from_str::<HashMap<String, ArlSession>>(&txt) {
+            *state.arl_sessions.write().await = map;
+        }
+    }
 }
 
 fn json_error(status: StatusCode, message: impl Into<String>) -> axum::response::Response {
@@ -592,15 +619,12 @@ async fn stream(
     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),
-            Err(e) => last_err = Some(e),
-        }
+        tracing::error!("stream {}: arl missing", q.id);
+        return (StatusCode::SERVICE_UNAVAILABLE, "arl required").into_response();
     }
 
-    // До 3 попыток: 0 — renew+запрос, 1 — сброс кэша клиента, 2 — ещё раз renew
+    // До 3 попыток
     for attempt in 0..3u8 {
         if url.is_some() { break; }
 
@@ -632,10 +656,11 @@ async fn stream(
 
     let url = match url {
         Some(u) => u,
-        None => return (
-            StatusCode::SERVICE_UNAVAILABLE,
-            last_err.unwrap_or_else(|| "stream:no_url".to_string()),
-        ).into_response(),
+        None => {
+            let err = last_err.unwrap_or_else(|| "stream:no_url".to_string());
+            tracing::error!("stream {} failed: {}", q.id, err);
+            return (StatusCode::SERVICE_UNAVAILABLE, err).into_response();
+        }
     };
 
     fn parse_range_header(v: &str) -> Option<(u64, Option<u64>)> {
@@ -2837,7 +2862,9 @@ async fn main() {
         arl_sessions: Arc::new(RwLock::new(HashMap::new())),
         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()),
     };
+    arl_store_load(&state).await;
     pair_store_load(&state).await;
 
     let cors = CorsLayer::new()