Update app.py

app.py

@@ -1,98 +1,159 @@
-from flask import Flask, jsonify
-import requests
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse
+import httpx
+import asyncio
 import time
 from datetime import datetime
-import threading
+from typing import Dict, List
 import os
 
-app = Flask(__name__)
+app = FastAPI(title="FastAPI Pinger", description="High-performance server warming service")
 
-# List of other pinger Spaces that will ping each other (add your Space URLs here)
+# Configuration
+PING_INTERVAL = 300  # 5 minutes
+HEALTH_CHECK_INTERVAL = 1800  # 30 minutes
+
+# List of other pinger Spaces (add your Space URLs here)
 pinger_spaces = [
     "https://rajhuggingface4253-ping2.hf.space",
     
-    
 ]
 
 # Your target servers to keep warm
-servers = [
-    "google.com",
-    "github.com", 
-    "stackoverflow.com",
-    "docker.com",
-    "python.org"
+target_servers = [
+    "https://rajhuggingface4253-qwen.hf.space",
+    "https://rajhuggingface4253-qwen2.hf.space", 
+    "https://rajhuggingface4253-qwen3.hf.space",
+    "https://rajhuggingface4253-backend-compressorpro.hf.space",
+    "https://rajhuggingface4253-backend-compressorpro2.hf.space"
+    "https://rajhuggingface4253-compressor3pro.hf.space"
+    "https://rajhuggingface4253-koko.hf.space"
 ]
 
-results = {}
-last_run = None
-health_pings = {}
+# Global state
+ping_results: Dict[str, Dict] = {}
+health_results: Dict[str, Dict] = {}
+last_ping_run: datetime = None
 
-def ping_server(url):
+async def ping_server(url: str) -> Dict:
+    """Ping a single server asynchronously"""
     try:
-        start = time.time()
-        response = requests.get(url if '://' in url else f'https://{url}', timeout=10)
+        start_time = time.time()
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            full_url = url if '://' in url else f'https://{url}'
+            response = await client.get(full_url)
+            response_time = round((time.time() - start_time) * 1000, 1)
+            
+            return {
+                'status': 'success',
+                'response_time_ms': response_time,
+                'status_code': response.status_code,
+                'timestamp': datetime.now().isoformat()
+            }
+    except Exception as e:
         return {
+            'status': 'error',
+            'error': str(e),
+            'timestamp': datetime.now().isoformat()
+        }
+
+async def ping_all_servers():
+    """Ping all target servers concurrently"""
+    global ping_results, last_ping_run
+    
+    tasks = [ping_server(server) for server in target_servers]
+    results = await asyncio.gather(*tasks)
+    
+    # Store results
+    for i, server in enumerate(target_servers):
+        ping_results[server] = results[i]
+    
+    last_ping_run = datetime.now()
+    
+    # Log results
+    success_count = sum(1 for result in results if result['status'] == 'success')
+    print(f"{datetime.now().strftime('%H:%M:%S')} - {success_count}/{len(target_servers)} servers OK")
+    
+    return results
+
+async def ping_health_endpoints():
+    """Ping other pinger Spaces concurrently"""
+    global health_results
+    
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        tasks = []
+        for space_url in pinger_spaces:
+            health_url = f"{space_url}/health"
+            tasks.append(ping_single_health(client, space_url, health_url))
+        
+        await asyncio.gather(*tasks)
+
+async def ping_single_health(client: httpx.AsyncClient, space_url: str, health_url: str):
+    """Ping a single health endpoint"""
+    try:
+        start_time = time.time()
+        response = await client.get(health_url)
+        response_time = round((time.time() - start_time) * 1000, 1)
+        
+        health_results[space_url] = {
             'status': 'success',
-            'response_time': round((time.time() - start) * 1000, 1),
-            'status_code': response.status_code
+            'response_time_ms': response_time,
+            'status_code': response.status_code,
+            'last_ping': datetime.now().isoformat()
         }
+        print(f"✅ Health ping to {space_url}: {response_time}ms")
     except Exception as e:
-        return {'status': 'error', 'error': str(e)}
+        health_results[space_url] = {
+            'status': 'error',
+            'error': str(e),
+            'last_ping': datetime.now().isoformat()
+        }
+        print(f"❌ Health ping failed for {space_url}: {e}")
 
-def ping_health_endpoints():
-    """Ping other pinger Spaces to keep them awake"""
-    for space_url in pinger_spaces:
+async def continuous_pinging():
+    """Main pinging loop"""
+    print("🚀 FastAPI Pinger Started!")
+    print(f"📊 Monitoring {len(target_servers)} target servers")
+    print(f"🔗 Connected to {len(pinger_spaces)} pinger spaces")
+    print(f"⏰ Pinging every {PING_INTERVAL//60} minutes")
+    
+    last_health_check = 0
+    
+    while True:
         try:
-            health_url = f"{space_url}/health"
-            start = time.time()
-            response = requests.get(health_url, timeout=10)
-            response_time = round((time.time() - start) * 1000, 1)
+            # Ping target servers
+            await ping_all_servers()
             
-            health_pings[space_url] = {
-                'status': 'success',
-                'response_time': response_time,
-                'status_code': response.status_code,
-                'last_ping': datetime.now().isoformat()
-            }
-            print(f"✅ Health ping to {space_url}: {response_time}ms")
+            # Ping health endpoints every 30 minutes
+            current_time = time.time()
+            if current_time - last_health_check >= HEALTH_CHECK_INTERVAL:
+                if pinger_spaces:
+                    print("🔄 Pinging other pinger spaces...")
+                    await ping_health_endpoints()
+                last_health_check = current_time
+            
+            # Wait for next cycle
+            await asyncio.sleep(PING_INTERVAL)
             
         except Exception as e:
-            health_pings[space_url] = {
-                'status': 'error',
-                'error': str(e),
-                'last_ping': datetime.now().isoformat()
-            }
-            print(f"❌ Health ping failed for {space_url}: {e}")
+            print(f"❌ Error in pinging loop: {e}")
+            await asyncio.sleep(60)  # Wait 1 minute before retrying
 
-def ping_all():
-    global results, last_run
-    while True:
-        print(f"{datetime.now().strftime('%H:%M:%S')} - Pinging {len(servers)} servers...")
-        
-        # Ping target servers
-        for server in servers:
-            results[server] = ping_server(server)
-        last_run = datetime.now()
-        
-        success = sum(1 for r in results.values() if r['status'] == 'success')
-        print(f"✅ {success}/{len(servers)} servers OK")
-        
-        # Ping other pinger Spaces every 30 minutes to keep them awake
-        if int(time.time()) % 1800 < 10:  # Every 30 minutes
-            print("🔄 Pinging other pinger Spaces...")
-            ping_health_endpoints()
-        
-        time.sleep(300)  # 5 minutes
+@app.on_event("startup")
+async def startup_event():
+    """Start the pinging loop when the app starts"""
+    asyncio.create_task(continuous_pinging())
 
-@app.route('/')
-def home():
-    success = sum(1 for r in results.values() if r['status'] == 'success') if results else 0
-    health_success = sum(1 for r in health_pings.values() if r.get('status') == 'success')
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    """Main dashboard"""
+    success_count = sum(1 for result in ping_results.values() if result.get('status') == 'success')
+    health_success = sum(1 for result in health_results.values() if result.get('status') == 'success')
     
-    return f"""
+    html_content = f"""
     <html>
         <head>
-            <title>Mutual Pinger</title>
+            <title>FastAPI Pinger</title>
             <style>
                 body {{ font-family: Arial, sans-serif; margin: 40px; }}
                 .success {{ color: green; }}
@@ -102,83 +163,67 @@ def home():
         </head>
         <body>
             <div class="container">
-                <h1>🔄 Mutual Pinger</h1>
-                <p>Monitoring {len(servers)} target servers</p>
-                <p>Connected to {len(pinger_spaces)} other pinger spaces</p>
-                <p><strong>Last run:</strong> {last_run or 'Not yet'}</p>
-                <p><strong>Target servers:</strong> {success}/{len(servers)} OK</p>
-                <p><strong>Pinger spaces:</strong> {health_success}/{len(pinger_spaces)} OK</p>
+                <h1>⚡ FastAPI Pinger</h1>
+                <p><strong>Target Servers:</strong> {len(target_servers)}</p>
+                <p><strong>Pinger Network:</strong> {len(pinger_spaces)}</p>
+                <p><strong>Last Run:</strong> {last_ping_run.strftime('%Y-%m-%d %H:%M:%S') if last_ping_run else 'Not yet'}</p>
+                <p><strong>Status:</strong> {success_count}/{len(target_servers)} servers OK • {health_success}/{len(pinger_spaces)} pingers OK</p>
                 
                 <h3>Endpoints:</h3>
                 <ul>
-                    <li><a href="/health">Health Check</a> (for other pingers)</li>
-                    <li><a href="/results">Ping Results</a></li>
-                    <li><a href="/network">Network Status</a></li>
-                    <li><a href="/ping-now">Force Ping Now</a></li>
+                    <li><a href="error</a></li>
                 </ul>
             </div>
         </body>
     </html>
     """
+    return HTMLResponse(content=html_content)
 
-@app.route('/health')
-def health():
-    """Health endpoint for other pinger Spaces to ping"""
-    return jsonify({
-        'status': 'healthy',
-        'service': 'mutual-pinger',
-        'timestamp': datetime.now().isoformat(),
-        'server_count': len(servers),
-        'pinger_network_count': len(pinger_spaces),
-        'last_ping_run': last_run.isoformat() if last_run else None
+@app.get("/health")
+async def health():
+    """Health endpoint for other pingers"""
+    return JSONResponse({
+        "status": "healthy",
+        "service": "fastapi-pinger",
+        "timestamp": datetime.now().isoformat(),
+        "server_count": len(target_servers),
+        "network_count": len(pinger_spaces),
+        "last_ping": last_ping_run.isoformat() if last_ping_run else None
     })
 
-@app.route('/results')
-def show_results():
-    return jsonify({
-        'last_run': last_run.isoformat() if last_run else None,
-        'target_servers': results,
-        'timestamp': datetime.now().isoformat()
+@app.get("/results")
+async def get_results():
+    """Get current ping results"""
+    return JSONResponse({
+        "last_run": last_ping_run.isoformat() if last_ping_run else None,
+        "target_servers": ping_results,
+        "pinger_network": health_results,
+        "timestamp": datetime.now().isoformat()
     })
 
-@app.route('/network')
-def network_status():
-    return jsonify({
-        'pinger_spaces': pinger_spaces,
-        'health_pings': health_pings,
-        'this_space_url': os.getenv('SPACE_URL', 'Unknown')
-    })
-
-@app.route('/ping-now')
-def ping_now():
+@app.get("/ping-now")
+async def ping_now():
     """Manually trigger a ping cycle"""
-    global results, last_run
-    print("🔄 Manual ping triggered")
-    
-    # Ping target servers
-    for server in servers:
-        results[server] = ping_server(server)
-    last_run = datetime.now()
+    results = await ping_all_servers()
+    if pinger_spaces:
+        await ping_health_endpoints()
     
-    # Ping other pinger spaces
-    ping_health_endpoints()
+    success_count = sum(1 for result in results if result['status'] == 'success')
+    health_success = sum(1 for result in health_results.values() if result.get('status') == 'success')
     
-    success = sum(1 for r in results.values() if r['status'] == 'success')
-    health_success = sum(1 for r in health_pings.values() if r.get('status') == 'success')
-    
-    return jsonify({
-        'message': 'Manual ping completed',
-        'target_servers_ok': f'{success}/{len(servers)}',
-        'pinger_spaces_ok': f'{health_success}/{len(pinger_spaces)}',
-        'timestamp': datetime.now().isoformat()
+    return JSONResponse({
+        "message": "Manual ping completed",
+        "servers_ok": f"{success_count}/{len(target_servers)}",
+        "pingers_ok": f"{health_success}/{len(pinger_spaces)}",
+        "timestamp": datetime.now().isoformat()
     })
 
-# Start background pinging
-threading.Thread(target=ping_all, daemon=True).start()
+@app.get("/docs")
+async def get_docs():
+    """Redirect to interactive docs"""
+    from fastapi.responses import RedirectResponse
+    return RedirectResponse(url="/docs")
 
-if __name__ == '__main__':
-    print("🚀 Mutual Pinger Started!")
-    print(f"📊 Monitoring {len(servers)} target servers")
-    print(f"🔗 Connected to {len(pinger_spaces)} pinger spaces")
-    print("⏰ Pinging every 5 minutes, health checks every 30 minutes")
-    app.run(host='0.0.0.0', port=7860)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)