Upload 7 files

main.py

@@ -0,0 +1,41 @@
+import asyncio
+import logging
+import uvicorn
+from contextlib import asynccontextmanager
+from web_server import app, init_app
+from proxy_manager import ProxyManager
+from updater import ProxyUpdater
+
+# Configure Logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("proxy_service.log")
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Initialize components
+pm = ProxyManager()
+updater = ProxyUpdater(pm)
+
+# Inject dependencies into web app
+init_app(pm, updater)
+
+@app.on_event("startup")
+async def startup_event():
+    """Start the updater loop when the application starts."""
+    logger.info("Application starting...")
+    asyncio.create_task(updater.run_loop())
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Clean up resources on shutdown."""
+    logger.info("Application shutting down...")
+    updater.stop()
+
+if __name__ == "__main__":
+    logger.info("Starting Proxy Rotation Service...")
+    uvicorn.run(app, host="0.0.0.0", port=7860)

proxy_manager.py

@@ -0,0 +1,136 @@
+import aiohttp
+import asyncio
+import time
+import logging
+from typing import List, Optional, Dict
+from dataclasses import dataclass, asdict
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+@dataclass
+class Proxy:
+    url: str
+    protocol: str
+    ip: str
+    port: str
+    latency: float = float('inf')
+
+    def to_dict(self):
+        return asdict(self)
+
+class ProxyManager:
+    def __init__(self):
+        self.proxies: List[Proxy] = [] # This will hold ONLY working proxies
+        self.best_proxy: Optional[Proxy] = None
+        self.test_target = "http://www.google.com" 
+        self.timeout = 5 # seconds
+        self.concurrency_limit = 200 # Higher concurrency
+        self._lock = asyncio.Lock() # Lock for thread-safe updates to self.proxies
+
+    async def fetch_json_proxies(self) -> List[Proxy]:
+        """Fetch proxies from proxies.free JSON source."""
+        url = f"https://proxies.free/data/proxies.json?t={int(time.time())}"
+        fetched = []
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        for p in data.get('proxies', []):
+                            # Filter for http/https/socks5 only
+                            protocol = p.get('protocol', '').lower()
+                            if protocol in ['http', 'https', 'socks5']:
+                                proxy_url = f"{protocol}://{p['ip']}:{p['port']}"
+                                fetched.append(Proxy(
+                                    url=proxy_url,
+                                    protocol=protocol,
+                                    ip=p['ip'],
+                                    port=p['port']
+                                ))
+        except Exception as e:
+            logger.error(f"Error fetching JSON proxies: {e}")
+        return fetched
+
+    async def fetch_txt_proxies(self) -> List[Proxy]:
+        """Fetch proxies from proxifly TXT source."""
+        url = "https://cdn.jsdelivr.net/gh/proxifly/free-proxy-list@main/proxies/all/data.txt"
+        fetched = []
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url) as response:
+                    if response.status == 200:
+                        text = await response.text()
+                        for line in text.splitlines():
+                            line = line.strip()
+                            if not line:
+                                continue
+                            try:
+                                protocol, rest = line.split('://')
+                                ip, port = rest.split(':')
+                                if protocol.lower() in ['http', 'https', 'socks5']:
+                                    fetched.append(Proxy(
+                                        url=line,
+                                        protocol=protocol.lower(),
+                                        ip=ip,
+                                        port=port
+                                    ))
+                            except ValueError:
+                                continue
+        except Exception as e:
+            logger.error(f"Error fetching TXT proxies: {e}")
+        return fetched
+
+    async def check_and_add_proxy(self, proxy: Proxy, semaphore: asyncio.Semaphore):
+        """Test a proxy and add it to the valid list immediately if successful."""
+        async with semaphore:
+            start_time = time.time()
+            try:
+                # Use a new session for each check to avoid connection pool limits/issues with proxies
+                timeout = aiohttp.ClientTimeout(total=self.timeout)
+                async with aiohttp.ClientSession(timeout=timeout) as session:
+                    async with session.get(self.test_target, proxy=proxy.url) as response:
+                        if response.status == 200:
+                            proxy.latency = (time.time() - start_time) * 1000 # ms
+                            
+                            # Add to working list immediately
+                            async with self._lock:
+                                self.proxies.append(proxy)
+                                self.proxies.sort(key=lambda x: x.latency)
+                                self.best_proxy = self.proxies[0]
+                                
+            except Exception:
+                pass # Check failed, just ignore
+
+    async def refresh_proxies(self) -> List[Proxy]:
+        """Fetch and test all proxies."""
+        logger.info("Fetching proxies...")
+        p1 = await self.fetch_json_proxies()
+        p2 = await self.fetch_txt_proxies()
+        
+        # Deduplicate
+        seen = set()
+        unique_proxies = []
+        for p in p1 + p2:
+            if p.url not in seen:
+                seen.add(p.url)
+                unique_proxies.append(p)
+        
+        logger.info(f"Testing {len(unique_proxies)} proxies with concurrency {self.concurrency_limit}...")
+        
+        # Reset current list before refresh? 
+        # Ideally, we keep old ones until new ones replace, but to keep it simple and stateless:
+        # We will clear it. UI might flicker but updates will come fast.
+        async with self._lock:
+            self.proxies = []
+            self.best_proxy = None
+
+        semaphore = asyncio.Semaphore(self.concurrency_limit)
+        tasks = [self.check_and_add_proxy(p, semaphore) for p in unique_proxies]
+        
+        # Run all checks
+        await asyncio.gather(*tasks)
+        
+        logger.info(f"Refresh complete. Found {len(self.proxies)} working proxies.")
+        return self.proxies

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+aiohttp
+aiohttp-socks
+requests
+schedule
+jinja2

templates/index.html

@@ -0,0 +1,229 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Proxy Rotation Service</title>
+    <style>
+        :root {
+            --bg-color: #0f172a;
+            --card-bg: #1e293b;
+            --text-primary: #f1f5f9;
+            --text-secondary: #94a3b8;
+            --accent: #3b82f6;
+            --success: #22c55e;
+            --error: #ef4444;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background-color: var(--bg-color);
+            color: var(--text-primary);
+            margin: 0;
+            padding: 2rem;
+            line-height: 1.6;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        header {
+            margin-bottom: 2rem;
+            border-bottom: 1px solid #334155;
+            padding-bottom: 1rem;
+        }
+
+        h1 {
+            font-weight: 300;
+            font-size: 2.5rem;
+            margin: 0;
+        }
+
+        .status-card {
+            background-color: var(--card-bg);
+            border-radius: 12px;
+            padding: 2rem;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .status-item {
+            text-align: center;
+        }
+
+        .status-label {
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+            margin-bottom: 0.5rem;
+        }
+
+        .status-value {
+            font-size: 1.5rem;
+            font-weight: bold;
+        }
+
+        .status-value.highlight {
+            color: var(--accent);
+        }
+
+        .proxy-list {
+            background-color: var(--card-bg);
+            border-radius: 12px;
+            overflow: hidden;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+
+        th,
+        td {
+            padding: 1rem;
+            text-align: left;
+            border-bottom: 1px solid #334155;
+        }
+
+        th {
+            background-color: #334155;
+            color: var(--text-primary);
+            font-weight: 600;
+        }
+
+        tr:hover {
+            background-color: #273548;
+        }
+
+        .latency-good {
+            color: var(--success);
+        }
+
+        .latency-bad {
+            color: var(--error);
+        }
+
+        .loading {
+            text-align: center;
+            padding: 2rem;
+            color: var(--text-secondary);
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <header>
+            <div style="display: flex; justify-content: space-between; align-items: center;">
+                <h1>Proxy Rotation Service</h1>
+                <div style="font-size: 0.8rem; color: var(--text-secondary);">Auto-refreshing every 2s</div>
+            </div>
+        </header>
+
+        <!-- Current Status -->
+        <div class="status-card">
+            <div class="status-item">
+                <div class="status-label">Current Best Proxy</div>
+                <div class="status-value highlight" id="best-proxy-url">Searching...</div>
+            </div>
+            <div class="status-item">
+                <div class="status-label">Protocol</div>
+                <div class="status-value" id="best-proxy-protocol">-</div>
+            </div>
+            <div class="status-item">
+                <div class="status-label">Latency</div>
+                <div class="status-value" id="best-proxy-latency">-</div>
+            </div>
+            <div class="status-item">
+                <div class="status-label">Total Active Proxies</div>
+                <div class="status-value" id="total-proxies">0</div>
+            </div>
+        </div>
+
+        <!-- Proxy List -->
+        <div class="proxy-list">
+            <table>
+                <thead>
+                    <tr>
+                        <th>Proxy URL</th>
+                        <th>Protocol</th>
+                        <th>IP</th>
+                        <th>Port</th>
+                        <th>Latency (ms)</th>
+                    </tr>
+                </thead>
+                <tbody id="proxy-table-body">
+                    <!-- Populated by JS -->
+                </tbody>
+            </table>
+            <div id="loading-msg" class="loading">Waiting for results...</div>
+        </div>
+    </div>
+
+    <script>
+        async def updateDashboard() {
+            try {
+                // Fetch Status
+                const statusRes = await fetch('/api/status');
+                const statusData = await statusRes.json();
+
+                const best = statusData.best_proxy;
+                document.getElementById('total-proxies').innerText = statusData.total_available;
+
+                if (best) {
+                    document.getElementById('best-proxy-url').innerText = best.url;
+                    document.getElementById('best-proxy-protocol').innerText = best.protocol.toUpperCase();
+
+                    const latency = best.latency.toFixed(2);
+                    const latEl = document.getElementById('best-proxy-latency');
+                    latEl.innerText = latency + ' ms';
+                    latEl.className = 'status-value ' + (best.latency < 200 ? 'latency-good' : 'latency-bad');
+                } else {
+                    document.getElementById('best-proxy-url').innerText = "Searching...";
+                    document.getElementById('best-proxy-protocol').innerText = "-";
+                    document.getElementById('best-proxy-latency').innerText = "-";
+                }
+
+                // Fetch Proxy List
+                const listRes = await fetch('/api/proxies');
+                const listData = await listRes.json();
+
+                const tbody = document.getElementById('proxy-table-body');
+                tbody.innerHTML = '';
+
+                if (listData.proxies.length > 0) {
+                    document.getElementById('loading-msg').style.display = 'none';
+                    listData.proxies.forEach(p => {
+                        const tr = document.createElement('tr');
+                        const latClass = p.latency < 200 ? 'latency-good' : 'latency-bad';
+                        tr.innerHTML = `
+                            <td>${p.url}</td>
+                            <td>${p.protocol}</td>
+                            <td>${p.ip}</td>
+                            <td>${p.port}</td>
+                            <td class="${latClass}">${p.latency.toFixed(2)}</td>
+                        `;
+                        tbody.appendChild(tr);
+                    });
+                }
+
+            } catch (e) {
+                console.error("Error updating dashboard:", e);
+            }
+        }
+
+        // Initial call
+        updateDashboard();
+
+        // Poll every 2 seconds
+        setInterval(updateDashboard, 2000);
+    </script>
+</body>
+
+</html>

updater.py

@@ -0,0 +1,61 @@
+import asyncio
+import logging
+import urllib.parse
+import aiohttp
+from proxy_manager import ProxyManager, Proxy
+
+logger = logging.getLogger(__name__)
+
+class ProxyUpdater:
+    def __init__(self, proxy_manager: ProxyManager):
+        self.pm = proxy_manager
+        self.update_url_template = "https://sasasas.zeabur.app/api/set/proxy/{}"
+        self.running = False
+
+    async def update_remote(self, proxy: Proxy):
+        """Update the remote instance with the new proxy."""
+        # URL encode the proxy URL
+        encoded_proxy = urllib.parse.quote(proxy.url, safe='')
+        target_url = self.update_url_template.format(encoded_proxy)
+        
+        logger.info(f"Updating remote instance with proxy: {proxy.url}")
+        logger.info(f"Target URL: {target_url}")
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(target_url) as response:
+                    text = await response.text()
+                    if response.status == 200:
+                        logger.info(f"Successfully updated remote proxy. Response: {text}")
+                    else:
+                        logger.error(f"Failed to update remote proxy. Status: {response.status}, Response: {text}")
+        except Exception as e:
+            logger.error(f"Exception during remote update: {e}")
+
+    async def run_loop(self):
+        """Main loop ensuring proxy is updated every 5 minutes."""
+        self.running = True
+        while self.running:
+            logger.info("Starting scheduled proxy update...")
+            
+            # 1. Refresh and find best proxy
+            proxies = await self.pm.refresh_proxies()
+            
+            if self.pm.best_proxy:
+                # 2. Test one last time before updating (as requested)
+                logger.info(f"Verifying best proxy {self.pm.best_proxy.url} before update...")
+                await self.pm.check_proxy(self.pm.best_proxy)
+                
+                if self.pm.best_proxy.latency != float('inf'):
+                    # 3. Update remote
+                    await self.update_remote(self.pm.best_proxy)
+                else:
+                    logger.warning("Best proxy failed verification. Retrying in next cycle.")
+            else:
+                logger.warning("No valid proxies found to update.")
+            
+            logger.info("Sleeping for 5 minutes...")
+            await asyncio.sleep(300) # 5 minutes
+
+    def stop(self):
+        self.running = False

web_server.py

@@ -0,0 +1,42 @@
+from fastapi import FastAPI, Request
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+import uvicorn
+from proxy_manager import ProxyManager
+from updater import ProxyUpdater
+import logging
+
+app = FastAPI()
+templates = Jinja2Templates(directory="templates")
+
+# These will be injected from main.py
+proxy_manager: ProxyManager = None
+updater: ProxyUpdater = None
+
+def init_app(pm: ProxyManager, up: ProxyUpdater):
+    global proxy_manager, updater
+    proxy_manager = pm
+    updater = up
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.get("/api/status")
+async def get_status():
+    if not proxy_manager:
+        return {"best_proxy": None, "total_available": 0}
+    
+    best = proxy_manager.best_proxy.to_dict() if proxy_manager.best_proxy else None
+    return {
+        "best_proxy": best,
+        "total_available": len(proxy_manager.proxies)
+    }
+
+@app.get("/api/proxies")
+async def get_proxies():
+    if not proxy_manager:
+        return {"proxies": []}
+    # Return top 50 proxies
+    return {"proxies": [p.to_dict() for p in proxy_manager.proxies[:50]]}