Whole code (check riccardo0731/ChatBot for original root - this is my part of code)

Author: GiZano

.dockerignore

@@ -0,0 +1,20 @@
+# Exclude client implementations to keep the server image small
+client/
+
+# Exclude Version Control System files
+.git
+.gitignore
+
+# Exclude IDE configurations
+.vscode
+.idea
+
+# Exclude Python cache and compiled files
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+
+# Exclude local virtual environments
+venv/
+env/

.github/workflows/docker-publish.yml

@@ -0,0 +1,46 @@
+name: Docker Publish
+
+on:
+  push:
+    branches: [ "main" ] # O 'master', controlla come si chiama il vostro branch
+    # Pubblica solo se vengono modificati file del server o utils
+    paths:
+      - 'server/**'
+      - 'utils.py'
+      - 'Dockerfile'
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: gizano/multithreaded-python-chat
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -0,0 +1 @@
+__pycache__/

Dockerfile

@@ -0,0 +1,25 @@
+# Use a lightweight Python base image to minimize container size
+FROM python:3.9-slim
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# 1. Copy the shared utility module to the project root
+# This is crucial because the server script expects utils.py in the parent directory
+COPY utils.py .
+
+# 2. Copy the entire server directory into /app/server
+COPY server/ ./server/
+
+# Environment Variables:
+# PYTHONDONTWRITEBYTECODE: Prevents Python from writing .pyc files
+# PYTHONUNBUFFERED: Ensures logs are flushed immediately to the terminal
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Expose the TCP port defined in the protocol
+EXPOSE 65432
+
+# Define the entry point command
+# We execute from /app so the script can resolve paths correctly
+CMD ["python", "server/server_main.py"]

README.md

@@ -0,0 +1,72 @@
+# 🚀 Private On-Premise TCP Chat System
+
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg?style=for-the-badge&logo=python)](https://www.python.org/)
+[![Docker Support](https://img.shields.io/badge/Docker-Ready-2496ED?style=for-the-badge&logo=docker)](https://www.docker.com/)
+[![Server Capacity](https://img.shields.io/badge/Capacity-%3E6000_Clients-brightgreen?style=for-the-badge)](https://github.com/riccard00731/ChatBot)
+
+An ultra-lightweight, high-performance, on-premise chat solution designed for secure communication within local networks. This system ensures data privacy by keeping traffic internal to the local network.
+
+## 🌟 Key Features
+* **Massive Scalability**: Engineered to handle over **6,000 concurrent connections** using optimized multithreading.
+* **Zero-Internet Dependency**: Works entirely within your LAN, preventing external data interception.
+* **Dockerized Deployment**: Includes a Docker configuration to make the server easily runnable everywher.
+* **Strict JSON Protocol**: A standardized messaging format used to communicate between all architecture components.
+* **Interactive Endpoints**: Built-in server commands for listing users, broadcasting, and server-time synchronization.
+
+---
+
+## 🏗️ Architecture
+The project implements a **Client-Server architecture**, also known as a **Star Topology**.
+* **Server**: A multithreaded TCP engine that manages a client registry and routes JSON packets.
+* **Client**: Utilizes two independent threads to handle simultaneous message sending and receiving.
+
+---
+
+## 🛠️ Tech Stack
+* **Language**: Python for rapid development and extensive library support.
+* **Core Libraries**: `socket` for networking, `threading` for concurrency, and `json` for data management.
+* **DevOps**: Docker for containerization and GitHub Actions for CI/CD.
+
+---
+
+## 🚀 Quick Start
+
+### Running with Docker
+1. **Clone the repo**:
+   ```bash
+   git clone https://github.com/gizano/multithreaded-python-chat.git
+   cd multithreaded-python-chat
+   ```
+2. **Launch the server**:
+   ```bash
+   docker-compose up -d
+   ```
+
+### Manual Execution
+1. **Start the Server**:
+   ```bash
+   python server/server_main.py
+   ```
+2. **Launch the Client**:
+   ```bash
+   python client/client_main.py
+   ```
+
+---
+
+## 📊 Performance & Testing
+Stability is our priority. We utilized **AI-generated testing suites** to push the server to its limits.
+* **Stress Test**: Simulates 50 bots performing handshake and random messaging.
+* **Breakpoint Test**: Confirmed hardware-bound stability at **6,000+ active users**.
+
+> **Technical Note**: The "TCP Coalescing" issue was addressed using the `time` library to prevent packet merging during registration.
+
+## 📡 Protocol Standard
+All communication must adhere to the following JSON schema:
+```json
+{
+  "from": { "name": "...", "ip": "..." },
+  "to": "...",
+  "msg": "..."
+}
+```

client/client_lib.py

@@ -0,0 +1,49 @@
+import sys
+import socket
+import utils
+
+"""
+    Name: receive_messages
+
+    Parameters: 
+        sock | socket object | socket of the client
+
+    Exceptions: 
+        Any | Error logged in the server terminal
+
+    Description: Function for the receiver thread, listens for incoming messages from the server and prints them on the screen.
+
+"""
+def receive_messages(sock):
+    """
+    Listens for incoming messages from the server and prints them to the standard output.
+    This function is intended to be executed in a separate thread to avoid blocking the main execution.
+    
+    Args:
+        sock (socket.socket): The active socket connection to the server.
+    """
+    while True:
+        try:
+            data = sock.recv(1024)
+            if not data:
+                print("\n[!] Disconnected from server.")
+                break
+            
+            # Decode the received data using the shared utility module
+            msg = utils.decode_json_msg(data)
+            
+            if msg:
+                # Format and display the message content
+                sender = msg['from']['name']
+                text = msg['msg']
+                print(f"\n >>> {sender}: {text}")
+                
+                # Restore the user input prompt to maintain UI consistency
+                print("To: ", end="", flush=True)
+                
+        except Exception as e:
+            print(f"\n[!] Receive Error: {e}")
+            break
+    
+    # If the connection loop terminates (e.g., server downtime), exit the application
+    sys.exit()

client/client_main.py

@@ -0,0 +1,78 @@
+import sys
+import os
+
+# 1. Retrieve the current directory path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+# 2. Navigate two levels up to locate the project root directory
+root_dir = os.path.abspath(os.path.join(current_dir, '..', '..'))
+# 3. Append the root directory to the system path to resolve shared modules
+sys.path.append(root_dir)
+
+import socket as sck
+import threading as thr
+import utils 
+import client_lib 
+import time
+
+def start_client():
+    my_ip = utils.get_local_ip()
+    
+    # Initial configuration and user setup
+    print(f"--- Client Group 3 ---")
+    server_host = input("Insert Server IP (press enter for localhost): ").strip() or "127.0.0.1"
+    my_name = input("Your Username: ").strip()
+
+    sock = sck.socket(sck.AF_INET, sck.SOCK_STREAM)
+    
+    try:
+        # Establish connection to the server
+        sock.connect((server_host, utils.PORT))
+    except ConnectionRefusedError:
+        print("[!] Impossible to connect to server. Check connectivity.")
+        return
+
+    # 1. Send username for registration (Handshake Protocol)
+    sock.send(my_name.encode(utils.ENCODING))
+
+    # 2. Start the receiving thread using the library function
+    # Note: Referencing client_lib.receive_messages
+    receiver_thread = thr.Thread(
+        target=client_lib.receive_messages, 
+        args=(sock,), 
+        daemon=True
+    )
+    receiver_thread.start()
+
+    print(f"--- Connected as {my_name} ({my_ip}) ---")
+    print("Message format -> Receiver, enter, message.")
+
+    # Little sleep to avaoid TCP Coalescing
+    time.sleep(0.1)
+
+    # Get commands list from server to show at the start to the user
+    to_user = "/help"
+    text = "x"
+    json_packet = utils.create_json_msg(my_name, my_ip, to_user, text)
+    sock.send(json_packet.encode(utils.ENCODING))
+
+
+    # 3. Sending Loop (Executes in the main thread)
+    try:
+        while True:
+            to_user = input("To: ")
+            text = input("Msg: ")
+
+            # Utilize the utility function to construct a valid JSON packet
+            json_packet = utils.create_json_msg(my_name, my_ip, to_user, text)
+            
+            sock.send(json_packet.encode(utils.ENCODING))
+            
+    except KeyboardInterrupt:
+        print("\nExiting...")
+    finally:
+        # Ensure the socket is properly closed upon termination
+        sock.close()
+
+
+if __name__ == "__main__":
+    start_client()

docker-compose.yml

@@ -0,0 +1,26 @@
+version: '3.8'
+
+services:
+  chat-server:
+    # Build the image using the Dockerfile in the current context (root)
+    build: 
+      context: .
+      dockerfile: Dockerfile
+    
+    # Assign a custom name to the container for easy identification
+    container_name: group3_server
+    
+    # Map host port 65432 to container port 65432
+    # Format: "HOST_PORT:CONTAINER_PORT"
+    ports:
+      - "65432:65432"
+    
+    # Restart policy: The container will restart automatically unless stopped manually
+    restart: unless-stopped
+    
+    # Resource limits (Optional: simulates a constrained production environment)
+    deploy:
+      resources:
+        limits:
+          cpus: '0.50'
+          memory: 512M