Create app.py

app.py

@@ -0,0 +1,229 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse
+import httpx
+import asyncio
+import time
+from datetime import datetime
+from typing import Dict, List
+import os
+
+app = FastAPI(title="FastAPI Pinger", description="High-performance server warming service")
+
+# 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-ping.hf.space",
+    
+]
+
+# Your target servers to keep warm
+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"
+]
+
+# Global state
+ping_results: Dict[str, Dict] = {}
+health_results: Dict[str, Dict] = {}
+last_ping_run: datetime = None
+
+async def ping_server(url: str) -> Dict:
+    """Ping a single server asynchronously"""
+    try:
+        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_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:
+        health_results[space_url] = {
+            'status': 'error',
+            'error': str(e),
+            'last_ping': datetime.now().isoformat()
+        }
+        print(f"❌ Health ping failed for {space_url}: {e}")
+
+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:
+            # Ping target servers
+            await ping_all_servers()
+            
+            # 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:
+            print(f"❌ Error in pinging loop: {e}")
+            await asyncio.sleep(60)  # Wait 1 minute before retrying
+
+@app.on_event("startup")
+async def startup_event():
+    """Start the pinging loop when the app starts"""
+    asyncio.create_task(continuous_pinging())
+
+@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')
+    
+    html_content = f"""
+    <html>
+        <head>
+            <title>FastAPI Pinger</title>
+            <style>
+                body {{ font-family: Arial, sans-serif; margin: 40px; }}
+                .success {{ color: green; }}
+                .error {{ color: red; }}
+                .container {{ max-width: 800px; margin: 0 auto; }}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <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="error</a></li>
+                </ul>
+            </div>
+        </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+@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.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.get("/ping-now")
+async def ping_now():
+    """Manually trigger a ping cycle"""
+    results = await ping_all_servers()
+    if pinger_spaces:
+        await 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')
+    
+    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()
+    })
+
+@app.get("/docs")
+async def get_docs():
+    """Redirect to interactive docs"""
+    from fastapi.responses import RedirectResponse
+    return RedirectResponse(url="/docs")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)