Update proxy_server.py

proxy_server.py

@@ -1,40 +1,42 @@
 """
-PROXY SERVER - Публичный сервер
-Схема: MT5 → PROXY → SAFE_BACKEND
-PROXY проверяет лицензию на SAFE_BACKEND и кэширует результаты
+PROXY SERVER - Публичный сервер на HF Spaces
+Получает запросы от MT5, кэширует, пробрасывает в Safe Backend
 """
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 import httpx
 import os
 import time
-import asyncio
 from datetime import datetime
+from typing import Optional
 
-# ==================== КОНФИГУРАЦИЯ ====================
+# ==================== КОНФИГУРАЦИЯ ИЗ СЕКРЕТОВ ====================
 class Config:
-    SAFE_BACKEND_URL = os.environ.get(
-    "SAFE_BACKEND_URL",
-    "https://askhat777-gold-backend-secure.hf.space"  # Проверь этот URL!
-)
-    SAFE_API_TOKEN = os.environ.get(
-        "SAFE_API_TOKEN",
-        "GOLD_SAFE_2026_u7x9A2B3C4D5E6F7G8H9I0J1K2L3M4N5O6P"
-    )
+    # Получаем из HF Secrets
+    SAFE_BACKEND_URL = os.environ.get("SAFE_BACKEND_URL")
+    SAFE_API_TOKEN = os.environ.get("SAFE_API_TOKEN")
+    
+    # Проверяем наличие
+    if not SAFE_BACKEND_URL:
+        raise ValueError("❌ SAFE_BACKEND_URL не установлен в HF Secrets!")
     
-    PRICE_CACHE_TTL = 1      # 1 секунда
-    LEVELS_CACHE_TTL = 60    # 1 минута
-    LICENSE_CACHE_TTL = 300  # 5 минут
+    if not SAFE_API_TOKEN:
+        raise ValueError("❌ SAFE_API_TOKEN не установлен в HF Secrets!")
+    
+    # TTL кэша
+    PRICE_CACHE_TTL = 1       # 1 секунда
+    LEVELS_CACHE_TTL = 60     # 1 минута
+    LICENSE_CACHE_TTL = 300   # 5 минут
 
 print("\n" + "=" * 70)
-print("⚙️  КОНФИГУРАЦИЯ PROXY")
+print("⚙️  ИНИЦИАЛИЗАЦИЯ PROXY")
 print("=" * 70)
-print(f"Safe Backend: {Config.SAFE_BACKEND_URL}")
-print(f"API Token: {'✓ УСТАНОВЛЕН' if os.environ.get('SAFE_API_TOKEN') else '✗ НЕ УСТАНОВЛЕН'}")
+print(f"✅ Safe Backend URL: {Config.SAFE_BACKEND_URL}")
+print(f"✅ SAFE_API_TOKEN загружен: {Config.SAFE_API_TOKEN[:20]}...")
 print("=" * 70 + "\n")
 
 # ==================== ИНИЦИАЛИЗАЦИЯ ====================
-app = FastAPI(title="Gold Proxy", version="1.2")
+app = FastAPI(title="Gold Proxy", version="1.3")
 
 app.add_middleware(
     CORSMiddleware,
@@ -44,14 +46,14 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ==================== КЭШИРОВАНИЕ ====================
+# ==================== КЭШ ПРОКСИ ====================
 class ProxyCache:
-    """Кэш Proxy с разделением по лицензиям"""
+    """Кэш для Proxy с разделением по лицензиям"""
     
     def __init__(self):
         self.cache = {}
         self.timestamps = {}
-        self.license_cache = {}  # Кэш для проверки лицензий
+        self.license_cache = {}
     
     def make_key(self, license_key: str, dte: int) -> str:
         return f"{license_key}_{dte}"
@@ -60,7 +62,7 @@ class ProxyCache:
         key = self.make_key(license_key, dte)
         self.cache[key] = data
         self.timestamps[key] = time.time()
-        print(f"💾 Кэш сохранен: {key}")
+        print(f"💾 Кэш сохранен: {key[:20]}...")
     
     def get(self, license_key: str, dte: int, ttl: int) -> tuple:
         key = self.make_key(license_key, dte)
@@ -76,81 +78,79 @@ class ProxyCache:
             return None, float('inf')
         
         return self.cache[key], age
-    
-    def cache_license_check(self, license_key: str, is_valid: bool):
-        """Кэширует результат проверки лицензии"""
-        self.license_cache[license_key] = {
-            'valid': is_valid,
-            'timestamp': time.time()
-        }
-    
-    def get_cached_license(self, license_key: str) -> tuple:
-        """Получает кэшированную проверку лицензии"""
-        if license_key in self.license_cache:
-            cached = self.license_cache[license_key]
-            age = time.time() - cached['timestamp']
-            
-            if age < Config.LICENSE_CACHE_TTL:
-                return cached['valid'], age
-            
-            del self.license_cache[license_key]
-        
-        return None, float('inf')
 
 proxy_cache = ProxyCache()
 
 # ==================== ЗАПРОСЫ К SAFE BACKEND ====================
-async def fetch_from_safe_backend(license_key: str, dte: int, client_ip: str) -> dict:
+async def fetch_from_safe_backend(
+    license_key: str,
+    dte: int,
+    client_ip: str
+) -> dict:
+    """Отправляет запрос в Safe Backend"""
+    
     url = f"{Config.SAFE_BACKEND_URL}/api/mt5/data"
     
     print(f"\n🔄 ЗАПРОС К SAFE BACKEND")
-    print(f"   Полный URL: {url}")  # ← Помогает отладить
-    print(f"   Метод: GET")
-    print(f"   Параметры: license_key={license_key}, dte={dte}")
+    print(f"   URL: {url}")
+    print(f"   License: {license_key}")
+    print(f"   DTE: {dte}")
     
     headers = {
         "X-API-Token": Config.SAFE_API_TOKEN,
-        "User-Agent": "Gold-Proxy/1.2",
+        "User-Agent": "Gold-Proxy/1.3",
         "X-Forwarded-For": client_ip,
     }
     
     try:
-        async with httpx.AsyncClient(
-            timeout=30.0,
-            verify=False  # ← Если проблема с SSL сертификатом
-        ) as client:
-            response = await client.get(url, params={
-                "license_key": license_key,
-                "dte": dte
-            }, headers=headers)
-            
-            print(f"   Response Status: {response.status_code}")
-            
-            if response.status_code == 200:
-                return response.json()
-            else:
-                print(f"   ❌ Error: {response.text[:200]}")
-                raise HTTPException(status_code=response.status_code)
-                
-    except httpx.ConnectError as e:
-        print(f"   ❌ Не удалось подключиться: {e}")
-        raise HTTPException(status_code=503, detail="Safe Backend недоступен")
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(
+                url,
+                params={"license_key": license_key, "dte": dte},
+                headers=headers
+            )
+        
+        print(f"   Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"   ✅ Данные получены: {data['calls_count']} calls, {data['puts_count']} puts")
+            return data
+        
+        elif response.status_code in [401, 403]:
+            print(f"   ❌ Ошибка авторизации (401/403)")
+            raise HTTPException(status_code=401, detail="License invalid")
+        
+        else:
+            print(f"   ❌ Ошибка {response.status_code}: {response.text[:100]}")
+            raise HTTPException(status_code=response.status_code, detail="Backend error")
+    
+    except httpx.TimeoutException:
+        print(f"   ❌ Timeout (30сек)")
+        raise HTTPException(status_code=504, detail="Backend timeout")
+    
+    except httpx.RequestError as e:
+        print(f"   ❌ Ошибка подключения: {str(e)}")
+        raise HTTPException(status_code=503, detail="Connection error")
+    
+    except Exception as e:
+        print(f"   ❌ Неизвестная ошибка: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
 # ==================== API ЭНДПОИНТЫ ====================
 @app.get("/")
 def root():
+    """Публичный информационный эндпоинт"""
     return {
-        "status": "Gold Proxy",
-        "version": "1.2",
-        "safe_backend": Config.SAFE_BACKEND_URL,
+        "name": "Gold Proxy",
+        "version": "1.3",
+        "status": "online",
         "cache_size": len(proxy_cache.cache),
-        "endpoints": {
-            "data": "/api/mt5/data?license_key=TEST_KEY_12345&dte=0",
-            "health": "/health"
-        }
     }
 
 @app.get("/health")
 def health_check():
+    """Healthcheck"""
     return {
         "status": "healthy",
         "timestamp": datetime.now().isoformat(),
@@ -166,63 +166,58 @@ async def proxy_mt5_data(
     """
     Основной прокси эндпоинт для MT5
     
-    1️⃣ Проверяет кэш
+    1️⃣ Проверяет кэш (1 минута)
     2️⃣ Если кэш устарел → запрашивает Safe Backend
-    3️⃣ Safe Backend проверяет лицензию
+    3️⃣ Safe Backend проверяет лицензию и токен
     4️⃣ Возвращает данные клиенту
     """
-    start_time = time.time()  # Перенесено внутрь функции
     
+    start_time = time.time()
     client_ip = request.client.host if request.client else "unknown"
+    
     print(f"\n📥 ЗАПРОС ОТ MT5")
     print(f"   IP: {client_ip}")
     print(f"   License: {license_key[:10]}...")
     print(f"   DTE: {dte}")
-
-    # 1️⃣ Проверяем кэш данных
-    # Предполагается, что proxy_cache и Config определены выше в вашем коде
-    cached_data, cache_age = proxy_cache.get(license_key, dte, Config.LEVELS_CACHE_TTL)
-
+    
+    # 1️⃣ Проверяем кэш
+    cached_data, cache_age = proxy_cache.get(
+        license_key,
+        dte,
+        Config.LEVELS_CACHE_TTL
+    )
+    
     if cached_data:
         elapsed = time.time() - start_time
         print(f"   ✅ Используется кэш (возраст {cache_age:.1f}сек)")
-        print(f"   📤 Ответ отправлен за {elapsed:.3f}сек")
+        print(f"   📤 Ответ за {elapsed:.3f}сек")
         return cached_data
-
+    
     print(f"   🔄 Кэш отсутствует или устарел")
-
-    # 2️⃣ Запрашиваем у Safe Backend
-    # Предполагается, что функция fetch_from_safe_backend определена и импортирована
+    
+    # 2️⃣ Запрашиваем Safe Backend
     try:
         data = await fetch_from_safe_backend(license_key, dte, client_ip)
     except Exception as e:
-        print(f"   ❌ Ошибка запроса к бэкенду: {e}")
-        # Можно вернуть ошибку клиенту или пустой объект, в зависимости от логики
-        raise HTTPException(status_code=500, detail="Safe Backend Error")
-
+        print(f"   ❌ Ошибка: {e}")
+        raise
+    
     # 3️⃣ Сохраняем в кэш
     proxy_cache.set(license_key, dte, data)
-
+    
     elapsed = time.time() - start_time
-    print(f"   📤 Ответ отправлен за {elapsed:.3f}сек")
-
+    print(f"   📤 Ответ за {elapsed:.3f}сек")
+    
     return data
 
-# ==================== ЗАПУСК ====================
-
 @app.on_event("startup")
 async def startup():
     print("\n" + "=" * 70)
-    print("🚀 PROXY SERVER ЗАПУЩЕН")
+    print("🚀 PROXY SERVER ГОТОВ К РАБОТЕ")
     print("=" * 70)
     print(f"Время: {datetime.now().isoformat()}")
-    # Проверьте, что Config.SAFE_BACKEND_URL существует
-    print(f"Safe Backend: {getattr(Config, 'SAFE_BACKEND_URL', 'Not Set')}")
-    safe_token = getattr(Config, 'SAFE_API_TOKEN', 'None')
-    print(f"API Token: {safe_token[:15]}..." if safe_token else "API Token: None")
+    print(f"Safe Backend: {Config.SAFE_BACKEND_URL}")
     print("=" * 70 + "\n")
 
 if __name__ == "__main__":
-    import uvicorn
-    # Убедитесь, что порт 7860 свободен (это стандартный порт для HF Spaces)
     uvicorn.run(app, host="0.0.0.0", port=7860)