Django server couldn't connect after I used Pyinstaller to compile into executable.

[Poltergeist1717]

I am building a School Management system using Django==5.0.6. The architecture of the project is that I used a Tkinter GUI to build the interface to interact with the Django server to run offline, this interface enables users to use buttons to trigger starting and terminating the server. This Tkinter app is the entry script in my app.spec file. I'm using waitress to server.

The code runs perfectly well when I run it from the terminal but won't work once I compile it with Pyinstaller which makes me confused.

Here is my .spec script:

# -*- mode: python ; coding: utf-8 -*-

import os
import sys
import pkg_resources
from PyInstaller.utils.hooks import collect_all
import logging

if getattr(sys, 'frozen', False):
    log_file_path = os.path.join(sys._MEIPASS, 'spec_log.log')
else:
    log_file_path = os.path.join(os.path.dirname(os.path.abspath(__name__)), 'spec_log.log')

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', filename=log_file_path, filemode='a')

block_cipher = None

spec_file_dir = os.path.abspath('.')
requirements_path = os.path.join(spec_file_dir, 'requirements.txt')

with open(requirements_path) as f:
    required_packages = [line.split('==')[0].replace('-', '_') for line in f.read().splitlines() if line and not line.startswith('#')]

customtkinter_datas, customtkinter_binaries, customtkinter_hiddenimports = collect_all('customtkinter')

installed_packages = [dist.project_name.replace('-', '_') for dist in pkg_resources.working_set]

logging.debug(f"Installed packages: {installed_packages}")

invalid_imports = ['pyinstaller_hooks_contrib']
valid_hiddenimports = [pkg for pkg in installed_packages if pkg not in invalid_imports]

logging.debug(f"Valid hidden imports: {valid_hiddenimports}")

datas = [
    ('cbt', 'cbt'),
    ('db.sqlite3', '.'),
    ('staticfiles/', 'staticfiles'),
    ('prominent/', 'prominent'),
    ('node_modules/', 'node_modules'),
    ('collectstatic/', 'collectstatic'),
    ('manage.py', '.'),
    ('migrate/', '.'),
    ('build_css/', '.'),
    ('migrations/', '.'),
    ('package.json', '.'),
    ('package-lock.json', '.'),
    ('run', '.'),
    ('tailwind.config.js', '.'),
    ('server_gui.py', '.'),
    ('pyinstaller_log.log', '.'),
    ('server_waitress_log.log', '.'),
    ('server_gui_log.log', '.'),
    ('start_waitress.py', '.'),
] + customtkinter_datas

hiddenimports = customtkinter_hiddenimports + required_packages + valid_hiddenimports + [
    'altgraph', 'asgiref', 'certifi', 'charset_normalizer', 'contourpy',
    'crispy_tailwind', 'cycler', 'darkdetect', 'django', 'django_crispy_forms',
    'et_xmlfile', 'fonttools', 'idna', 'kiwisolver', 'lxml', 'matplotlib',
    'numpy', 'openpyxl', 'packaging', 'pandas', 'pillow',
    'pyparsing', 'python_dateutil', 'python_docx', 'pytz', 'requests', 'six',
    'sqlparse', 'typing_extensions', 'tzdata', 'win32com',
    'win32com.client', 'urllib3', 'whitenoise', 'XlsxWriter', 'waitress', 'whitenoise.middleware',
    'customtkinter', 'portalocker', 'setuptools',
]

a = Analysis(
    ['server_gui.py'],
    pathex=['.'],
    binaries=[],
    datas=datas,
    hiddenimports=hiddenimports,
    hookspath=['.'],
    runtime_hooks=['hooks/dorm_runtime_hook.py'],
    excludes=[],
    win_no_prefer_redirects=False,
    win_private_assemblies=False,
    cipher=block_cipher,
    noarchive=False,
)
pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)

exe = EXE(
    pyz,
    a.scripts,
    [],
    exclude_binaries=True,
    name='Dorm',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=False,
    console=False,
    bundle_files=1
)

coll = COLLECT(
    exe,
    a.binaries,
    a.zipfiles,
    a.datas,
    strip=False,
    upx=False,
    name='Dorm'
)

here is the server.gui script:

"""
ServerGUI Application

This module defines a GUI application to manage a server. The application provides
functionalities to start, stop, refresh the server, and perform various checks like
server listening status, connection testing, and firewall rule management.

Dependencies:
    - subprocess
    - tkinter as tk
    - customtkinter as ctk
    - os
    - webbrowser
    - tkinter.messagebox as messagebox
    - logging
    - socket
    - platform
    - time
    - threading
    - sys
    - atexit
    - tempfile
    - portalocker
    - psutil
    - queue.Queue, queue.Empty

Classes:
    - ServerGUI: A class to manage the server through a GUI.
    
Methods:
    - __init__(self): Initialize the ServerGUI instance, acquire a file lock, set up logging, initialize attributes, 
                        configure the GUI, create widgets, and set up the layout.

    - setup_logging(self): Set up logging for the application to capture debug and error information.

    - initialize_attributes(self): Initialize various attributes used in the class, 
                                    such as server start time, timer thread, port, server process, and others.

    - configure_gui(self): Configure the appearance of the GUI, setting the appearance mode and theme.

    - create_widgets(self): Create the various widgets used in the GUI, including labels, buttons, text boxes, and frames.

    - setup_layout(self): Set up the layout of the widgets in the GUI using grid and pack layout managers.

    - acquire_lock(self): Acquire a file lock to ensure only one instance of the application is running.

    - release_lock(self): Release the file lock upon application exit.

    - logout(self): Exit the application.

    - use_default_ip(self): Use the default IP address (127.0.0.1) for the server.

    - get_ip_address(self): Get and set the IP address for the server by detecting the current machine's IP address.

    - detect_ip_address(self): Detect the IP address of the current machine, with retries and fallback to the loopback address if necessary.

    - start_server(self): Start the server by first validating the IP address and then initiating the server start process in a new thread.

    - start_server_thread(self): Thread target to start the server process, with retries in case of failure.

    - update_status(self, message, color='yellow'): Update the status label in the GUI with a given message and color.

    - show_info(self, title, message): Show an informational message box with a given title and message.

    - show_error(self, title, message): Show an error message box with a given title and message.

    - update_copy_url_textbox(self, url): Update the URL textbox in the GUI with the provided URL.

    - update_error_textbox(self, message): Update the error textbox in the GUI with the provided error message.

    - stop_server(self): Stop the server, confirming with the user if necessary, and initiate the server termination process in a new thread.

    - terminate_server_process(self): Terminate the server process, handling threads and errors appropriately, and restart if the server was refreshing.

    - refresh_server(self): Refresh the server by stopping and restarting it, confirming with the user if necessary.

    - collect_server_errors(self): Collect errors from the server's stderr stream and display them in the error textbox.

    - update_timer(self): Update the timer label with the elapsed time since the server started, running in a separate thread.

    - check_timer_queue(self): Check the queue for the latest elapsed time and update the timer label, scheduling the next check.

    - check_server_listening(self): Check if the server is listening on the specified port and update the status label accordingly.

    - test_server_connection(self): Test the connection to the server by sending an HTTP request and update the status label with the result.

    - ping_server(self): Ping the server to check its reachability and update the status label with the result.

    - add_firewall_rule(self): Add firewall rules for the server based on the operating system, with administrative permissions required.


Functions:
    - is_valid_ip_address: Validate if the given IP address is valid.
    - add_firewall_rule_windows: Add firewall rules for Windows OS.
    - add_firewall_rule_linux: Add firewall rules for Linux OS.
    - add_firewall_rule_macos: Add firewall rules for MacOS.
    - ping_server: Ping a server to check its reachability.
"""

import subprocess
import tkinter as tk
import customtkinter as ctk
import os
import webbrowser
import tkinter.messagebox as messagebox
import logging
import socket
import platform
import time
import threading
import sys
import atexit
import tempfile
import portalocker
import psutil
import webview
from queue import Queue, Empty


def is_valid_ip_address(ip_address):
    """
    Validate if the given IP address is valid.

    Args:
        ip_address (str): IP address to validate.

    Returns:
        bool: True if valid, False otherwise.
    """
    if ip_address.lower() == 'localhost':
        return True
    try:
        # Try validating as an IPv4 address
        socket.inet_aton(ip_address)
        return ip_address.count('.') == 3
    except socket.error:
        pass
    try:
        # Try validating as an IPv6 address
        socket.inet_pton(socket.AF_INET6, ip_address)
        return True
    except socket.error:
        return False

class ServerGUI(ctk.CTk):
    """
    A GUI application to manage a server.

    This class provides methods to start, stop, and refresh the server, 
    and check its status and connectivity.

    Attributes:
        lockfile (file): File object for the lock file.
        lock_file_path (str): Path to the lock file.
        server_start_time (float): Start time of the server.
        timer_thread (threading.Thread): Thread for updating the server running time.
        port (int): Port number on which the server runs.
        running (bool): Indicates if the server is running.
        server_process (subprocess.Popen): Process object for the server.
        collect_server_errors_thread (threading.Thread): Thread for collecting server errors.
        timer_queue (Queue): Queue to handle server running time updates.
        ip_address (str): IP address of the server.
        refreshing_server (bool): Indicates if the server is being refreshed.
        default_ip_used (bool): Indicates if the default IP address is used.
    """

    def __init__(self):
        """
        Initialize the ServerGUI instance.
        """
        super().__init__()

        self.lockfile = None

        if getattr(sys, 'frozen', False):
            self.lock_file_path = os.path.join(sys._MEIPASS,  'my_app.lock')
        else:
            self.lock_file_path = os.path.join(tempfile.gettempdir(), 'my_app.lock')

        # Attempt to acquire the lock
        self.acquire_lock()

        self.setup_logging()
        self.initialize_attributes()
        self.configure_gui()
        self.create_widgets()
        self.setup_layout()

    def setup_logging(self):
        """
        Set up logging for the application.
        """
        if getattr(sys, 'frozen', False):
            log_file_path = os.path.join(sys._MEIPASS, 'server_gui_log.log')
        else:
            log_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'server_gui_log.log')

        logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', filename=log_file_path, filemode='a')
        logging.debug('Logging setup complete')
        logging.debug(f'Working directory: {os.getcwd()}')
        logging.debug(f'System path: {sys.path}')
        logging.debug(f'Environment variables: {os.environ}')

    def initialize_attributes(self):
        """
        Initialize the attributes of the ServerGUI instance.
        """
        self.server_start_time = None
        self.timer_thread = None
        self.port = None
        self.running = False
        self.server_process = None
        self.collect_server_errors_thread = None
        self.timer_queue = Queue()

    def configure_gui(self):
        """
        Configure the appearance of the GUI.
        """
        ctk.set_appearance_mode("Dark")
        ctk.set_default_color_theme("dark-blue")
        self.title('Dorm Server Starter')
        self.geometry('900x500')

    def create_widgets(self):
        """
        Create the widgets for the GUI.
        """
        self.ip_frame = ctk.CTkFrame(self)
        self.ip_label = ctk.CTkLabel(self.ip_frame, text='IP Address:', font=("Arial", 15, "bold"), text_color="white")
        self.ip_input = ctk.CTkEntry(self.ip_frame, width=300, height=35, font=("Arial", 12))

        self.os_label = ctk.CTkLabel(self, text='Select your OS type (or auto-detect):', font=("Arial", 15, "bold"), text_color="white")
        self.os_frame = ctk.CTkFrame(self)
        self.os_var = tk.StringVar(value='Auto')
        self.os_auto = ctk.CTkRadioButton(self.os_frame, text='Auto', variable=self.os_var, value='Auto')
        self.os_windows = ctk.CTkRadioButton(self.os_frame, text='Windows', variable=self.os_var, value='Windows')
        self.os_linux = ctk.CTkRadioButton(self.os_frame, text='Linux', variable=self.os_var, value='Linux')

        self.button_frame = ctk.CTkFrame(self)
        self.default_button = ctk.CTkButton(self.button_frame, text='Use Default IP', command=self.use_default_ip, width=150, height=35, font=("Arial", 12))
        self.ip_button = ctk.CTkButton(self.button_frame, text='Get IP Address', command=self.get_ip_address, width=150, height=35, font=("Arial", 12))
        self.start_button = ctk.CTkButton(self.button_frame, text='Start Server', command=self.start_server, width=150, height=35, font=("Arial", 12), fg_color="green", hover_color="darkgreen")
        self.stop_button = ctk.CTkButton(self.button_frame, text='Stop Server', command=self.stop_server, width=150, height=35, font=("Arial", 12), fg_color="red", hover_color="darkred")
        self.refresh_button = ctk.CTkButton(self.button_frame, text='Refresh Server', command=self.refresh_server, width=150, height=35, font=("Arial", 12), fg_color="orange", hover_color="darkorange")
        self.check_listening_button = ctk.CTkButton(self.button_frame, text='Check Server Port Listening', command=self.check_server_listening, width=150, height=35, font=("Arial", 12))
        self.test_connection_button = ctk.CTkButton(self.button_frame, text='Test Server Connection', command=self.test_server_connection, width=150, height=35, font=("Arial", 12))
        self.ping_button = ctk.CTkButton(self.button_frame, text='Ping Server', command=self.ping_server, width=150, height=35, font=("Arial", 12))
        self.firewall_button = ctk.CTkButton(self.button_frame, text='Add Firewall Rule', command=self.add_firewall_rule, width=150, height=35, font=("Arial", 12))

        self.timer_label = ctk.CTkLabel(self, text='Server running time: 0s', font=("Arial", 15, "bold"))
        self.second_frame = ctk.CTkScrollableFrame(self, height=10, width=100)
        self.label_frame = ctk.CTkScrollableFrame(self.second_frame, height=10, width=100)

        self.status_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
        self.listening_status_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
        self.connection_listening_status_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
        self.ping_result_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
        self.firewall_result_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
        self.output_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="red")

        self.copy_url_textbox = tk.Text(self.second_frame, wrap='word', height=2, width=40, bg="black", fg="white", font=("Arial", 9))
        self.error_textbox = tk.Text(self.second_frame, wrap='word', height=10, width=100, bg="black", fg="red", font=("Arial", 9))

    def setup_layout(self):
        """
        Set up the layout of the widgets in the GUI.
        """
        self.ip_frame.pack(pady=5)
        self.ip_label.grid(row=0, column=0, padx=5, pady=5)
        self.ip_input.grid(row=0, column=1, padx=5, pady=5)

        self.os_label.pack(pady=10)
        self.os_frame.pack(pady=5)
        self.os_auto.grid(row=0, column=0, padx=5, pady=5)
        self.os_windows.grid(row=0, column=1, padx=5, pady=5)
        self.os_linux.grid(row=0, column=2, padx=5, pady=5)

        self.button_frame.pack(pady=8)
        self.default_button.grid(row=0, column=0, padx=5, pady=5)
        self.ip_button.grid(row=0, column=1, padx=5, pady=5)
        self.start_button.grid(row=0, column=2, padx=5, pady=5)
        self.stop_button.grid(row=0, column=3, padx=5, pady=5)
        self.refresh_button.grid(row=1, column=0, padx=5, pady=5)
        self.check_listening_button.grid(row=1, column=1, padx=5, pady=5)
        self.test_connection_button.grid(row=1, column=2, padx=5, pady=5)
        self.ping_button.grid(row=1, column=3, padx=5, pady=5)
        self.firewall_button.grid(row=2, column=0, padx=5, pady=5)

        self.timer_label.pack(pady=4)
        self.second_frame.pack(pady=4, fill='both', expand=True)
        self.label_frame.pack(pady=2, fill='both', expand=True)

        self.status_label.pack(pady=2)
        self.listening_status_label.pack(pady=2)
        self.connection_listening_status_label.pack(pady=5)
        self.ping_result_label.pack(pady=2)
        self.firewall_result_label.pack(pady=2)
        self.output_label.pack(pady=2)

        self.copy_url_textbox.pack(pady=5)
        self.error_textbox.pack(pady=10)
    
    def acquire_lock(self):
        """
        Acquire a file lock to ensure only one instance of the application is running.
        """
        self.lockfile = open(self.lock_file_path, 'w')
        try:
            portalocker.lock(self.lockfile, portalocker.LOCK_EX | portalocker.LOCK_NB)
        except portalocker.LockException:
            messagebox.showerror("Error", "Another instance of this application is already running.")
            self.lockfile.close()
            sys.exit(-1)  # Exit only this instance
        atexit.register(self.release_lock)

    def release_lock(self):
        """
        Release the file lock upon application exit.
        """
        try:
            portalocker.unlock(self.lockfile)
        except Exception as e:
            logging.error(f"Error releasing file lock: {e}")
        self.lockfile.close()

    def logout(self):
        """
        Exit the application.
        """
        try:
            sys.exit()
        except Exception as e:
            logging.error(f"Something went wrong while quitting app: {e}")
            self.quit()
            self.destroy()

    def use_default_ip(self):
        """
        Use the default IP address (192.168.1.100) for the server.
        """
        if self.server_process and self.server_process.poll() is None:
            messagebox.showerror("Server Currently Running", "A server is currently running. You don't need another IP address")
            return
        else:
            self.ip_address = '192.168.1.100'  # Ensure self.ip_address is set
            self.ip_input.delete(0, ctk.END)
            self.ip_input.insert(0, self.ip_address)
            messagebox.showwarning("Default IP - Network congiguration Required", "Kindly ensure the default IP address: '192.168.1.100' communicates on your network\nAnd not currently in use by another service.")
            self.status_label.configure(text='Using default IP address: 192.168.1.100')
            self.default_ip_used = True  # Track if the default IP is used

    def get_ip_address(self):
        """
        Get and set the IP address for the server.
        """
        if self.server_process and self.server_process.poll() is None:
            messagebox.showerror("Server Currently Running", "A server is currently running. You don't need another IP address")
            return
        else:
            if hasattr(self, 'default_ip_used') and self.default_ip_used:
                self.default_ip_used = False
                self.ip_address = ' '  # Ensure self.ip_address is cleared 
            else:
                self.ip_address = self.detect_ip_address()  # Ensure self.ip_address is set

            self.ip_input.delete(0, ctk.END)
            self.ip_input.insert(0, self.ip_address)
            self.status_label.configure(text=f'IP address detected: {self.ip_address}')

    def detect_ip_address(self):
        """
        Detect the IP address of the current machine.

        Returns:
            str: Detected IP address.
        """
        os_type = platform.system()

        retries = 3
        for attempt in range(retries):
            try:
                if os_type in ['Windows', 'Linux', 'Darwin']:
                    preferred_interfaces = ['Wi-Fi', 'Ethernet', 'eth0', 'wlan0']

                    # Get all network interfaces and their stats
                    interfaces = psutil.net_if_addrs()
                    interface_stats = psutil.net_if_stats()

                    # First, try to find a preferred interface with a valid IPv4 address and is up
                    for interface in preferred_interfaces:
                        if interface in interfaces and interface_stats[interface].isup:
                            for addr in interfaces[interface]:
                                if addr.family == socket.AF_INET and not addr.address.startswith("127."):
                                    return addr.address

                    # If no preferred interface found, look for any non-loopback IPv4 address that is up
                    for interface, addrs in interfaces.items():
                        if interface_stats[interface].isup:
                            for addr in addrs:
                                if addr.family == socket.AF_INET and not addr.address.startswith("127."):
                                    return addr.address
                else:
                    raise ValueError("Unsupported OS type for IP detection.")
            except Exception as e:
                logging.error(f'Error detecting IP address: {e}')
                time.sleep(1)
                
        messagebox.showinfo("No Reachable IP Address", "There's no reachable IP Address because you're not connected to any network so it fallback to the default IP Address.\nKindly ensure you've configured your network to communicate on the default IP address: '192.168.1.100'")
        # Fallback to loopback address if no valid IP found
        return '192.168.1.100'
    
    def start_server(self):
        """
        Start the server.
        """
        if self.server_process and self.server_process.poll() is None:
            messagebox.showerror("Server Currently Running", "You can't start another server while one server is currently running")
            return

        if hasattr(self, 'refreshing_server') and self.refreshing_server:
            self.ip_address = self.ip_input.get() if self.ip_input.get() != "" else '192.168.1.100'
            threading.Thread(target=self.start_server_thread).start()
            self.refreshing_server = False
        else:
            self.ip_address = self.ip_input.get() or '192.168.1.100'

            if not is_valid_ip_address(self.ip_address):
                messagebox.showerror("Invalid IP Address", "The provided IP address is not valid.")
                self.status_label.configure(text='Invalid IP address provided', text_color='red')
                self.title('Dorm Server Starter - Invalid IP address')
                return

            if self.ip_address == '192.168.1.100':
                confirm = messagebox.askquestion("Confirm Starting Server at '192.168.1.100'", '''Are you sure you want to start the server at '192.168.1.100'? \n Please ensure you've configured your network to access the IP Address: 192.168.1.100''')
                if confirm != 'yes':
                    messagebox.showerror("Choose an IP Address", "Kindly input your desired correct local IP address or use the Get IP Address button")
                    self.status_label.configure(text='No Server is currently running')
                    self.title('Dorm Server Starter - No Server is currently running')
                    return

            # Start the server in a new thread
            threading.Thread(target=self.start_server_thread).start()

    def start_server_thread(self):
        """
        Thread target to start the server process.
        """
        try:
            self.port = 8000

            self.update_status(f'Starting server at IP address: {self.ip_address} on port {self.port}')
            self.title('Dorm Server Starter - Server is Starting.......')
            self.show_info("Server Status", "Server is starting.......")

            env = os.environ.copy()
            env["RUNNING_SERVER"] = "1"
            env["DJANGO_SETTINGS_MODULE"] = 'cbt.settings'
            env['LOCAL_IP_ADDRESS'] = self.ip_address
            env['PORT'] = str(self.port)

            logging.debug(f'Environment before starting server: {env}')

            if getattr(sys, 'frozen', False):
                server_script_file_path = os.path.join(sys._MEIPASS, 'start_waitress.py')
            else:
                server_script_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'start_waitress.py')

            logging.debug(f'Server script file path: {server_script_file_path}')

            creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == 'nt' else 0
            
            # Ensure no lingering processes are using the IP and port before starting a new one
            self.find_and_terminate_processes(self.ip_address, self.port)

            # Initial attempt
            self.server_process = subprocess.Popen(
                [sys.executable, server_script_file_path, self.ip_address, str(self.port), "6"],
                env=env, creationflags=creationflags,
                stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                cwd=os.path.dirname(server_script_file_path),
            )

            time.sleep(2)  # Short delay to let the process start and potentially fail

            # Check if the initial attempt failed
            if self.server_process.poll() is not None:
                exit_code = self.server_process.returncode
                print(f"The exit code from start_server_thread method: {exit_code}")
                self.handle_start_failure(server_script_file_path=server_script_file_path, env=env, creationflags=creationflags, exit_code=exit_code)
            else:
                # Enhanced check to verify server connection
                if self.is_server_responding():
                    logging.debug(f"Server process started with PID: {self.server_process.pid}")
                    self.finalize_successful_start()
                else:
                    exit_code = self.server_process.poll()  # Check again if the process has terminated
                    print(f"The exit code from start_server_thread method: {exit_code}")
                    if exit_code is None:
                        logging.debug("Server is not responding but process has not terminated yet.")
                        self.find_and_terminate_processes(self.ip_address, self.port)  # Ensure the process is terminated
                    self.handle_start_failure(server_script_file_path=server_script_file_path, env=env, creationflags=creationflags, exit_code=exit_code)

        except Exception as e:
            self.update_status(f'Error starting server: {e}', 'red')
            self.show_error("Server Error", f"Error starting server: {e}")
            logging.error(f"Error starting server: {e}")
            self.title('Dorm Server Starter - Error')

    def handle_start_failure(self, server_script_file_path, env, creationflags, exit_code):
        """
        Handle server start failure by retrying.
        """
        retries = 3
        for attempt in range(retries):
            try:
                print(f"Retry attempt {attempt + 1} with exit code: {exit_code}")
                if exit_code == 1:
                    self.update_status(f'OSError: Ensure you have permissions to bind to the port and/or your IP Address is reachable\nand not currently in use by another service on your network.', 'red')
                    messagebox.showerror("OSError: Server Failed", '''OSError: Please ensure you're connected to a network and/or your IP Address is reachable\nand not currently in use by another service on your network.\nEnsure you have permissions to bind to the port: 8000.''')
                elif exit_code == None:
                    self.update_status(f'OSError: Ensure you have permissions to bind to the port and/or your IP Address is reachable\nand not currently in use by another service on your network.', 'red')
                    messagebox.showerror("OSError: Server Failed", '''OSError: Please ensure you're connected to a network and/or your IP Address is reachable\nand not currently in use by another service on your network.\nEnsure you have permissions to bind to the port: 8000.''')
                elif exit_code == 2:
                    self.update_status(f'General Error: Error starting the server', 'red')
                    messagebox.showerror("Waitress Error", "Error starting waitress server")
                else:
                    self.update_status(f'Unknown Error: Server process exited with code {exit_code}', 'red')

                logging.error(f"Server process failed to start with exit code {exit_code}")
                logging.warning(f'Server start attempt {attempt + 1} failed. Retrying...')
                self.update_status(f'Server start attempt {attempt + 1} failed. Retrying...', 'yellow')

                self.server_process = subprocess.Popen(
                    [sys.executable, server_script_file_path, self.ip_address, str(self.port), "6"],
                    env=env, creationflags=creationflags,
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                    cwd=os.path.dirname(server_script_file_path),
                )

                time.sleep(2)  # Short delay to let the process start and potentially fail
                
                # Ensure any lingering subprocess is terminated before starting a new one
                self.find_and_terminate_processes(self.ip_address, self.port)

                # Check the exit code after the retry attempt
                if self.server_process.poll() is not None:
                    exit_code = self.server_process.returncode
                    print(f"The exit code from handle_start_failure method: {exit_code}")
                    raise Exception("Server process failed to start")

                if self.is_server_responding():
                    self.finalize_successful_start()
                    break  # Exit the loop if the server started successfully

            except Exception as e:
                logging.error(f"Retry {attempt + 1} failed: {e}")
                if attempt < retries - 1:
                    time.sleep(2)  # Wait before retrying
                else:
                    self.update_status(f"Server process failed to start after three (3) attempts - KINDLY RESTART SERVER", 'red')
                    self.title(f'Dorm Server Starter - Server failed to connect at: http://{self.ip_address}:{self.port}/')
                    messagebox.showerror("Server Failed...", "Server process failed to start after three (3) attempts - Kindly Restart Server")
    
    def finalize_successful_start(self):
        """
        Finalize the server start process after a successful attempt.
        """
        if self.server_process and self.server_process.poll() is None and self.server_process.stderr:
            self.collect_server_errors_thread = threading.Thread(target=self.collect_server_errors)
            self.collect_server_errors_thread.start()

        if self.server_process and self.server_process.poll() is None:
            self.update_status(f'Server running at IP address: {self.ip_address} on port {self.port}', 'green')
            self.title(f'Dorm Server Starter - Server running at: http://{self.ip_address}:{self.port}/')
            self.update_copy_url_textbox(f'Copy your URL: http://{self.ip_address}:{self.port}/')
            self.show_info("Server Status", "The server has started")

            logging.debug(f'Environment variables after the server has started: {os.environ}')
            logging.debug(f"Server process PID after server has started: {self.server_process.pid}")

            self.running = True
            self.server_start_time = time.time()
            self.timer_thread = threading.Thread(target=self.update_timer)
            self.timer_thread.start()
            self.check_timer_queue()

            webbrowser.open(f'http://{self.ip_address}:{self.port}/')
    
    def is_server_responding(self):
        """
        Check if the server is responding by attempting to open a socket connection.
        """
        try:
            with socket.create_connection((self.ip_address, self.port), timeout=5) as sock:
                sock.shutdown(socket.SHUT_RDWR)
                return True
        except (socket.timeout, ConnectionRefusedError, OSError):
            return False
            
    def update_status(self, message, color='yellow'):
        """
        Update the status label in the GUI.

        Args:
            message (str): The status message to display.
            color (str): The color of the status message.
        """
        self.after(0, lambda: self.status_label.configure(text=message, text_color=color))

    def show_info(self, title, message):
        """
        Show an informational message box.

        Args:
            title (str): The title of the message box.
            message (str): The message to display.
        """
        self.after(0, lambda: messagebox.showinfo(title, message))

    def show_error(self, title, message):
        """
        Show an error message box.

        Args:
            title (str): The title of the message box.
            message (str): The message to display.
        """
        self.after(0, lambda: messagebox.showerror(title, message))

    def update_copy_url_textbox(self, url):
        """
        Update the URL textbox in the GUI.

        Args:
            url (str): The URL to display.
        """
        self.after(0, lambda: self.copy_url_textbox.insert(tk.END, url))
        self.after(0, lambda: self.copy_url_textbox.see(tk.END))

    def update_error_textbox(self, message):
        """
        Update the error textbox in the GUI.

        Args:
            message (str): The error message to display.
        """
        self.after(0, lambda: self.error_textbox.insert(tk.END, message))
        self.after(0, lambda: self.error_textbox.see(tk.END))

    def stop_server(self):
        """
        Stop the server.
        """
        if self.server_process and self.server_process.poll() is None:
            if hasattr(self, 'refreshing_server') and self.refreshing_server:
                self.status_label.configure(text='Refreshing server...', text_color='yellow')
                self.title('Dorm Server Starter - Refreshing server...')
                self.running = False
                # Start a thread to terminate the server process
                threading.Thread(target=self.terminate_server_process).start()
            else:
                confirm = messagebox.askquestion("Confirm Exit", "Are you sure you want to stop the server?")
                if confirm == 'yes':
                    self.status_label.configure(text='Stopping server...')
                    self.title('Dorm Server Starter - Terminating server...')
                    self.running = False
                    # Start a thread to terminate the server process
                    threading.Thread(target=self.terminate_server_process).start()
                else:
                    self.status_label.configure(text=f'Server running at IP address: {self.ip_address}')
                    self.title(f'Dorm Server Starter - Server running at: {self.ip_address}')
        else:
            self.status_label.configure(text='No server running')
            messagebox.showwarning("Server Status", "No server is currently running")
            self.title('Dorm Server Starter - No Server Running')
            confirm = messagebox.askquestion("Server Status - No server is currently running", "Would you like to quit?")
            if confirm == 'yes':
                self.logout()  # Quit the Tkinter main loop

    def terminate_server_process(self):
        """
        Terminate the server process and ensure the server connection is properly shut down.
        """
        try:
            if self.timer_thread:
                self.timer_thread.join()
            if self.collect_server_errors_thread:
                self.collect_server_errors_thread.join()

            # Terminate the server process
            if self.server_process and self.server_process.poll() is None:
                logging.info("Terminating the server process.")
                self.server_process.terminate()
                try:
                    self.server_process.wait(timeout=5)
                except subprocess.TimeoutExpired:
                    logging.warning("Server process did not terminate in time. Forcing kill.")
                    self.server_process.kill()
                    self.server_process.wait()

            # Ensure the server socket is closed
            self.close_server_connection()

            if hasattr(self, 'refreshing_server') and self.refreshing_server:
                messagebox.showinfo("Dorm Server Refresh", 'The server has terminated, the server will refresh now')
                self.after(200, self.start_server)
            else:
                messagebox.showinfo("Dorm Server Starter", 'The server has terminated, the app will Exit now')
                self.after(100, self.logout)  # Schedule the logout method to be called after a short delay

        except Exception as e:
            logging.error(f"The server process didn't terminate properly: {e}")
            self.server_process.kill()
            self.server_process.wait()
            self.close_server_connection()
            self.after(100, self.logout)  # Schedule the logout method to be called after a short delay

    def close_server_connection(self):
        """
        Close the server connection explicitly.
        """
        try:
            logging.info("Attempting to close the server connection...")

            # Create a connection to the server to close it
            with socket.create_connection((self.ip_address, self.port), timeout=5) as sock:
                logging.info("Connection established. Shutting down the server connection.")
                sock.shutdown(socket.SHUT_RDWR)
                sock.close()
            logging.info("Server connection closed successfully.")
            
        except (socket.timeout, ConnectionRefusedError, OSError) as e:
            logging.info(f"Server connection already closed or could not be established: {e}")    
        
        # Ensure no lingering processes are using the IP and port
        self.find_and_terminate_processes(self.ip_address, self.port)

        # Ensure all related processes are terminated
        if self.server_process and self.server_process.poll() is None:
            logging.info(f"Terminating server process with PID: {self.server_process.pid}")
            self.server_process.terminate()
            try:
                self.server_process.wait(timeout=5)
            except subprocess.TimeoutExpired:
                logging.warning("Server process did not terminate in time. Forcing kill.")
                self.server_process.kill()
                self.server_process.wait()

        # Ensure all child processes are terminated
        if self.server_process:
            try:
                parent_process = psutil.Process(self.server_process.pid)
                children = parent_process.children(recursive=True)
                for child in children:
                    logging.info(f"Terminating child process with PID: {child.pid}")
                    child.terminate()
                    try:
                        child.wait(timeout=5)
                    except psutil.TimeoutExpired:
                        logging.warning(f"Child process with PID {child.pid} did not terminate in time. Forcing kill.")
                        child.kill()
            except psutil.NoSuchProcess:
                logging.info("Parent process does not exist anymore.")

        logging.info("Server connection cleanup completed.")     
        
    def find_and_terminate_processes(self, ip, port):
        """
        Find and terminate any processes that are listening on the given IP address and port.
        """
        try:
            # Get all current connections
            connections = psutil.net_connections(kind='inet')

            for conn in connections:
                # Check if the connection matches the IP and port
                if conn.laddr.ip == ip and conn.laddr.port == port:
                    logging.info(f"Found lingering process with PID {conn.pid} on {ip}:{port}")
                    try:
                        # Get the process using the connection's PID
                        proc = psutil.Process(conn.pid)
                        logging.info(f"Terminating process {proc.pid} ({proc.name()})")
                        proc.terminate()
                        try:
                            proc.wait(timeout=5)
                            logging.info(f"Terminated process {proc.pid} ({proc.name()})")
                        except psutil.TimeoutExpired:
                            logging.warning(f"Process {proc.pid} did not terminate in time. Forcing kill.")
                            proc.kill()
                            proc.wait()
                    except psutil.NoSuchProcess:
                        logging.info(f"Process {conn.pid} no longer exists.")
        except Exception as e:
            logging.error(f"Error finding and terminating processes: {e}")

    def refresh_server(self):
        """
        Refresh the server by stopping and restarting it.
        """
        if self.server_process and self.server_process.poll() is None:
            try:
                confirm = messagebox.askquestion("Confirm Restart", "Are you sure you want to refresh the server?")
                if confirm == 'yes':
                    self.refreshing_server = True  # Track if it is refreshing server
                    self.stop_server()  # Stop the server, which will internally call terminate_server_process
                else:
                    self.status_label.configure(text=f'Server running at IP address: {self.ip_address} on port {self.port}')
                    self.title(f'Dorm Server Starter - Server running at: {self.ip_address}')
            except Exception as e:
                logging.error(f"There was an error refreshing the server: {e}")
                self.refreshing_server = False  # Turn False for refreshing server
                self.status_label.configure(text=f'Error refreshing server on: {self.ip_address} on port {self.port}', text_color='red')
                return
        else:
            self.status_label.configure(text='No server running to refresh')
            messagebox.showwarning("Server Status", "No server is currently running")
            self.title('Dorm Server Starter - No Server Running')
            return

    def collect_server_errors(self):
        """
        Collect errors from the server's stderr stream.
        """
        try:
            # Continuously collect server errors as long as the server is running
            while self.running and self.server_process and self.server_process.stderr:
                try:
                    for line in iter(self.server_process.stderr.readline, b''):
                        self.error_textbox.insert(tk.END, line.decode())
                        self.error_textbox.see(tk.END)
                        logging.error(line.decode())
                    self.server_process.stderr.close()
                except ValueError:
                    logging.error("Attempted to read from a closed stderr stream.")
                    break
        except Exception as e:
            logging.error(f"Error collecting server errors: {e}")

    def update_timer(self):
        """
        Update the timer label with the elapsed time since the server started.
        """
        # Update the timer label with the elapsed time since the server started
        while self.running:
            if self.server_start_time:
                elapsed_time = int(time.time() - self.server_start_time)
                self.timer_queue.put(elapsed_time)
                time.sleep(1)

    def check_timer_queue(self):
        """
        Check the queue for the latest elapsed time and update the timer label.
        """
        try:
            # Check the queue for the latest elapsed time and update the timer label
            elapsed_time = self.timer_queue.get_nowait()
            self.timer_label.configure(text=f'Server running time: {elapsed_time}s')
        except Empty:
            pass
        # Schedule the next check
        self.after(1000, self.check_timer_queue)

    def check_server_listening(self):
        """
        Check if the server is listening on the specified port.
        """
        if self.server_process and self.server_process.poll() is None:
            port = self.port
            os_type = platform.system().lower()
            cmd = []

            if os_type == 'windows':
                cmd = ['netstat', '-an']
            elif os_type in ['linux', 'darwin']:
                cmd = ['ss', '-an']
            else:
                self.listening_status_label.configure(text=f'Unsupported OS for checking listening ports', text_color='red')
                return

            try:
                if os.name == 'nt':
                    # Set up the startup info to prevent the console window from appearing
                    startupinfo = subprocess.STARTUPINFO()
                    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                    
                    result = subprocess.run(cmd, capture_output=True, text=True, startupinfo=startupinfo)
                if result.returncode != 0:
                    raise subprocess.CalledProcessError(result.returncode, cmd, output=result.stdout, stderr=result.stderr)

                output = result.stdout.lower()
                listening = any(f'tcp' in line and f':{port}' in line for line in output.splitlines())

                if listening:
                    self.listening_status_label.configure(text=f'Server is listening on port {port}', text_color='green')
                else:
                    self.listening_status_label.configure(text=f'Server is not listening on port {port}', text_color='red')

            except Exception as e:
                self.listening_status_label.configure(text=f'Error checking server listening: {e}', text_color='red')
                logging.error(f'Error checking server listening: {e}')
        else:
            messagebox.showerror('No server to listen', 'There is no server running to listen')

    def test_server_connection(self):
        """
        Test the connection to the server.
        """
        if self.server_process and self.server_process.poll() is None:
            url = f'http://{self.ip_address}:{self.port}'
            os_type = platform.system().lower()
            cmd = []

            if os_type == 'windows':
                cmd = ['curl', '-s', '-o', 'NUL', '-w', '%{http_code}', url]
            elif os_type in ['linux', 'darwin']:
                cmd = ['wget', '-q', '--spider', '--server-response', url]
            else:
                self.connection_listening_status_label.configure(text=f'Unsupported OS for testing connection', text_color='red')
                return

            try:
                if os.name == 'nt':
                    # Set up the startup info to prevent the console window from appearing
                    startupinfo = subprocess.STARTUPINFO()
                    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

                    result = subprocess.run(cmd, capture_output=True, text=True, startupinfo=startupinfo)
                else:
                    result = subprocess.run(cmd, capture_output=True, text=True)

                if result.returncode == 0:
                    self.connection_listening_status_label.configure(text=f'Successfully connected to {url}', text_color='green')
                else:
                    self.connection_listening_status_label.configure(text=f'Failed to connect to {url}: {result.stderr}', text_color='red')
                    logging.error(f'Failed to connect to {url}: {result.stderr}')
            except Exception as e:
                self.connection_listening_status_label.configure(text=f'Error testing server connection: {e}', text_color='red')
                logging.error(f'Error testing server connection: {e}')
        else:
            messagebox.showerror('No server to check connection', 'There is no server running to check connection')

    def ping_server(self):
        """
        Ping the server to check its reachability.
        """
        try:
            ip_address = self.ip_input.get() or '192.168.1.100'
            result = ping_server(ip_address)
            self.ping_result_label.configure(text=result)
        except Exception as e:
            self.status_label.configure(text=f'There was error trying to ping address: {e}')
            self.title("Dorm Server Starter - Error - Can't ping")
            

    def add_firewall_rule(self):
        """
        Add firewall rules for the server.
        """
        ask_permission = messagebox.askyesno('Permission Required', 'Did you run the app as an administrator?')
        if ask_permission:
            if self.server_process and self.server_process.poll() is None:
                port = self.port or 8000
                os_type = platform.system().lower()
                if os_type == 'windows':
                    result = add_firewall_rule_windows(port)
                elif os_type == 'linux':
                    result = add_firewall_rule_linux(port)
                elif os_type == 'darwin':
                    result = add_firewall_rule_macos(port)
                else:
                    result = f'Unsupported OS for adding firewall rule'
                self.error_textbox.insert(tk.END, result)
                self.error_textbox.see(tk.END)
            else:
                self.status_label.configure(text='No server running to add firewall rules for')
                messagebox.showerror("Server Status", "No server is currently running - Can't add firewall rules")
                self.title("Dorm Server Starter - No Server Running - Can't add firewall rules")
        else:
            messagebox.showerror("Permission Required", "Administrative permission required to perform this task!")
            return 

def add_firewall_rule_windows(port):
    """
    Add firewall rules for Windows OS.

    Args:
        port (int): Port number for which to add the firewall rules.

    Returns:
        str: Result message indicating success or failure.
    """
    try:
        # Set up the startup info to prevent the console window from appearing
        startupinfo = subprocess.STARTUPINFO()
        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
        subprocess.run(["netsh", "advfirewall", "firewall", "add", "rule", 
                        "name=AllowPort{}".format(port), 
                        "dir=in", "action=allow", "protocol=TCP", 
                        "localport={}".format(port)], check=True, startupinfo=startupinfo)
        subprocess.run(["netsh", "advfirewall", "firewall", "add", "rule", 
                        "name=AllowPort{}".format(port), 
                        "dir=out", "action=allow", "protocol=TCP", 
                        "localport={}".format(port)], check=True, startupinfo=startupinfo)
        return "Firewall rules added successfully for port {}".format(port)
    except subprocess.CalledProcessError as e:
        return "Error adding firewall rule: {}".format(e)

def add_firewall_rule_linux(port):
    """
    Add firewall rules for Linux OS.

    Args:
        port (int): Port number for which to add the firewall rules.

    Returns:
        str: Result message indicating success or failure.
    """
    try:
        # Set up the startup info to prevent the console window from appearing
        startupinfo = subprocess.STARTUPINFO()
        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
        subprocess.run(["sudo", "iptables", "-A", "INPUT", "-p", "tcp", "--dport", str(port), "-j", "ACCEPT"], check=True, startupinfo=startupinfo)
        subprocess.run(["sudo", "iptables", "-A", "OUTPUT", "-p", "tcp", "--dport", str(port), "-j", "ACCEPT"], check=True, startupinfo=startupinfo)
        return "Firewall rules added successfully for port {}".format(port)
    except subprocess.CalledProcessError as e:
        return "Error adding firewall rule: {}".format(e)

def add_firewall_rule_macos(port):
    """
    Add firewall rules for MacOS.

    Args:
        port (int): Port number for which to add the firewall rules.

    Returns:
        str: Result message indicating success or failure.
    """
    try:
        # Set up the startup info to prevent the console window from appearing
        startupinfo = subprocess.STARTUPINFO()
        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
        rule = "pass in proto tcp from any to any port {}".format(port)
        subprocess.run(["echo", rule, "|", "sudo", "pfctl", "-f", "-"], shell=True, check=True, startupinfo=startupinfo)
        subprocess.run(["sudo", "pfctl", "-e"], check=True, startupinfo=startupinfo)
        return "Firewall rules added successfully for port {}".format(port)
    except subprocess.CalledProcessError as e:
        return "Error adding firewall rule: {}".format(e)

def ping_server(ip_address):
    """
    Ping a server to check its reachability.

    Args:
        ip_address (str): IP address of the server to ping.

    Returns:
        str: Result message indicating success or failure of the ping.
    """
    param = '-n' if platform.system().lower() == 'windows' else '-c'
    command = ['ping', param, '4', ip_address]

    try:
        # Set up the startup info to prevent the console window from appearing
        startupinfo = subprocess.STARTUPINFO()
        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
        output = subprocess.check_output(command, universal_newlines=True, startupinfo=startupinfo)
        return output
    except subprocess.CalledProcessError as e:
        messagebox.showerror("Error - Ping Failed", "Ping failed due to: {}".format(e))
        return "Ping failed: {}".format(e)

if __name__ == '__main__':
    if "GUI_ALREADY_RUNNING" not in os.environ:
        os.environ["GUI_ALREADY_RUNNING"] = "1"
        app = ServerGUI()
        app.mainloop()

What could be the problem?

[bwoodsend]

We're not going to be able to help you at all based on no minimal reproducer and no error message.

[Poltergeist1717]

There is no particular error message displayed, I have updated the question to show the server_gui.py script.

[rokm]

           if getattr(sys, 'frozen', False):
               server_script_file_path = os.path.join(sys._MEIPASS, 'start_waitress.py')
           else:
               server_script_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'start_waitress.py')

           logging.debug(f'Server script file path: {server_script_file_path}')

           creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == 'nt' else 0
           
           # Ensure no lingering processes are using the IP and port before starting a new one
           self.find_and_terminate_processes(self.ip_address, self.port)

           # Initial attempt
           self.server_process = subprocess.Popen(
               [sys.executable, server_script_file_path, self.ip_address, str(self.port), "6"],
               env=env, creationflags=creationflags,
               stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
               cwd=os.path.dirname(server_script_file_path),
           )

At a (very cursory) glance, you are trying to spawn a subprocess using sys.executable as if it were python interpreter executable. But in the frozen application, that is not the case - sys.executable points to your application executable. So your server subprocess enters the entry-point script, but because GUI_ALREADY_RUNNING is already set, it does nothing.

If you want to use embedded python interpreter of the frozen application to run arbitrary script, you will need to detect such invocation in your entry-point script (the most fool-proof way would be to add a command-line argument, but you could also just check if argv contains the server script filename), and divert your program flow into codepath that reads the script file and runs it via exec().

[Poltergeist1717]

Thank you, I will look into it and if this solves the problem, I'll inform you of the development.

[Poltergeist1717]

I have updated my code to use exec(), however, I am still facing the same issue where the server connects only when I run it from the terminal. The thing is I don't get any special error message when I run the executable, it just loads and fails every connection attempts

Here is how I addressed the issue, I might still be doing it wrong:

I updated the start_server method to set a --run_server enviromen variable and then look for that in the main function to know which one to use to run the start_waitress.py script just as the below:

def start_server(self):
"""
Start the server.
"""
if self.server_process and self.server_process.poll() is None:
messagebox.showerror("Server Currently Running", "You can't start another server while one server is currently running")
return

    if hasattr(self, 'refreshing_server') and self.refreshing_server:
        self.ip_address = self.ip_input.get() if self.ip_input.get() != "" else '192.168.1.100'
        threading.Thread(target=self.start_server_thread).start()
        self.refreshing_server = False
    else:
        self.ip_address = self.ip_input.get() or '192.168.1.100'

        if not is_valid_ip_address(self.ip_address):
            messagebox.showerror("Invalid IP Address", "The provided IP address is not valid.")
            self.status_label.configure(text='Invalid IP address provided', text_color='red')
            self.title('Dorm Server Starter - Invalid IP address')
            return

        if self.ip_address == '192.168.1.100':
            confirm = messagebox.askquestion("Confirm Starting Server at '192.168.1.100'", "Are you sure you want to start the server at '192.168.1.100'?")
            if confirm != 'yes':
                messagebox.showerror("Choose an IP Address", "Kindly input your desired correct local IP address or use the Get IP Address button")
                self.status_label.configure(text='No Server is currently running')
                self.title('Dorm Server Starter - No Server is currently running')
                return

        # Start the server in a new thread
        threading.Thread(target=self.start_server_thread).start()

def start_server_thread(self):
    """
    Thread target to start the server process.
    """
    try:
        self.port = 8000
        
        self.threads = 6

        self.update_status(f'Starting server at IP address: {self.ip_address} on port {self.port}')
        self.title('Dorm Server Starter - Server is Starting.......')
        self.show_info("Server Status", "Server is starting.......")

        env = os.environ.copy()
        env["RUNNING_SERVER"] = "1"
        env["DJANGO_SETTINGS_MODULE"] = 'cbt.settings'
        env['LOCAL_IP_ADDRESS'] = self.ip_address
        env['PORT'] = str(self.port)

        logging.debug(f'Environment before starting server: {env}')

        if getattr(sys, 'frozen', False):
            server_script_file_path = os.path.join(sys._MEIPASS, 'start_waitress.py')
        else:
            server_script_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'start_waitress.py')

        logging.debug(f'Server script file path: {server_script_file_path}')

        creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == 'nt' else 0

        # Ensure no lingering processes are using the IP and port before starting a new one
        self.find_and_terminate_processes(self.ip_address, self.port)
        
        logging.debug(f"Arguments for server process: {sys.executable} --run-server {server_script_file_path} {self.ip_address} {self.port}")
        
        # Initial attempt
        if getattr(sys, 'frozen', False):
            logging.debug(f"Running frozen app with: {sys.executable}, --run-server, {server_script_file_path}, {self.ip_address}, {str(self.port)}")
            self.server_process = subprocess.Popen(
                [sys.executable, '--run-server', server_script_file_path, self.ip_address, str(self.port), str(self.threads)],
                env=env, creationflags=creationflags,
                stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                cwd=os.path.dirname(server_script_file_path),
            )
        else:
            logging.debug(f"Running non-frozen app with: {sys.executable}, {server_script_file_path}, {self.ip_address}, {str(self.port)}")
            self.server_process = subprocess.Popen(
                [sys.executable, server_script_file_path, self.ip_address, str(self.port), str(self.threads)],
                env=env, creationflags=creationflags,
                stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                cwd=os.path.dirname(server_script_file_path),
            )

        time.sleep(40)  # Short delay to let the process start and potentially fail

        # Check if the initial attempt failed
        if self.server_process.poll() is not None:
            exit_code = self.server_process.returncode
            self.handle_start_failure(server_script_file_path=server_script_file_path, env=env, creationflags=creationflags, exit_code=exit_code)
        else:
            # Enhanced check to verify server connection
            if self.is_server_responding():
                logging.debug(f"Server process started with PID: {self.server_process.pid}")
                self.finalize_successful_start()
            else:
                exit_code = self.server_process.returncode
                self.handle_start_failure(server_script_file_path=server_script_file_path, env=env, creationflags=creationflags, exit_code=exit_code)

    except Exception as e:
        self.update_status(f'Error starting server: {e}', 'yellow')
        self.show_error("Server Error", f"Error starting server: {e}")
        logging.error(f"Error starting server: {e}")
        self.title('Dorm Server Starter - Error')

def run_main_application():
if "GUI_ALREADY_RUNNING" not in os.environ:
os.environ["GUI_ALREADY_RUNNING"] = "1"
app = ServerGUI()
app.mainloop()

def main():
if len(sys.argv) > 1 and sys.argv[1] == '--run-server':
# Execute the server script
server_script_path = sys.argv[2]
server_ip = sys.argv[3]
server_port = int(sys.argv[4])
threads = int(sys.argv[5])

    print(f"IP address in def main(): {server_ip}")
    print(f"Port in def main(): {server_port}")
    print(f"Threads in def mian(): {threads}")
    
    logging.debug(f'IP address in main(): {server_ip}')
    logging.debug(f'Port in main(): {server_port}')
    logging.debug(f'Threads in mian(): {threads}')
    
    logging.debug(f'Running server with script: {server_script_path}, IP: {server_ip}, Port: {server_port}, threads: {threads}')
    
    with open(server_script_path) as f:
        code = f.read()
    exec(code, {'__name__': '__main__', 'sys': sys, 'os': os, 'ip_address': server_ip, 'port': server_port, 'threads': threads})
else:
    # The regular entry point for your main application
    run_main_application()

if name == 'main':
run_as_admin()
main()

Here is the full code again:

"""
ServerGUI Application

This module defines a GUI application to manage a server. The application provides
functionalities to start, stop, refresh the server, and perform various checks like
server listening status, connection testing, and firewall rule management.

Dependencies:
- subprocess
- tkinter as tk
- customtkinter as ctk
- os
- webbrowser
- tkinter.messagebox as messagebox
- logging
- socket
- platform
- time
- threading
- sys
- atexit
- tempfile
- portalocker
- psutil
- queue.Queue, queue.Empty

Classes:
- ServerGUI: A class to manage the server through a GUI.

Methods:
- init(self): Initialize the ServerGUI instance, acquire a file lock, set up logging, initialize attributes,
configure the GUI, create widgets, and set up the layout.

- setup_logging(self): Set up logging for the application to capture debug and error information.

- initialize_attributes(self): Initialize various attributes used in the class, 
                                such as server start time, timer thread, port, server process, and others.

- configure_gui(self): Configure the appearance of the GUI, setting the appearance mode and theme.

- create_widgets(self): Create the various widgets used in the GUI, including labels, buttons, text boxes, and frames.

- setup_layout(self): Set up the layout of the widgets in the GUI using grid and pack layout managers.

- acquire_lock(self): Acquire a file lock to ensure only one instance of the application is running.

- release_lock(self): Release the file lock upon application exit.

- logout(self): Exit the application.

- use_default_ip(self): Use the default IP address (127.0.0.1) for the server.

- get_ip_address(self): Get and set the IP address for the server by detecting the current machine's IP address.

- detect_ip_address(self): Detect the IP address of the current machine, with retries and fallback to the loopback address if necessary.

- start_server(self): Start the server by first validating the IP address and then initiating the server start process in a new thread.

- start_server_thread(self): Thread target to start the server process, with retries in case of failure.

- update_status(self, message, color='yellow'): Update the status label in the GUI with a given message and color.

- show_info(self, title, message): Show an informational message box with a given title and message.

- show_error(self, title, message): Show an error message box with a given title and message.

- update_copy_url_textbox(self, url): Update the URL textbox in the GUI with the provided URL.

- update_error_textbox(self, message): Update the error textbox in the GUI with the provided error message.

- stop_server(self): Stop the server, confirming with the user if necessary, and initiate the server termination process in a new thread.

- terminate_server_process(self): Terminate the server process, handling threads and errors appropriately, and restart if the server was refreshing.

- refresh_server(self): Refresh the server by stopping and restarting it, confirming with the user if necessary.

- collect_server_errors(self): Collect errors from the server's stderr stream and display them in the error textbox.

- update_timer(self): Update the timer label with the elapsed time since the server started, running in a separate thread.

- check_timer_queue(self): Check the queue for the latest elapsed time and update the timer label, scheduling the next check.

- check_server_listening(self): Check if the server is listening on the specified port and update the status label accordingly.

- test_server_connection(self): Test the connection to the server by sending an HTTP request and update the status label with the result.

- ping_server(self): Ping the server to check its reachability and update the status label with the result.

- add_firewall_rule(self): Add firewall rules for the server based on the operating system, with administrative permissions required.

Functions:
- is_valid_ip_address: Validate if the given IP address is valid.
- add_firewall_rule_windows: Add firewall rules for Windows OS.
- add_firewall_rule_linux: Add firewall rules for Linux OS.
- add_firewall_rule_macos: Add firewall rules for MacOS.
- ping_server: Ping a server to check its reachability.
"""

import subprocess
import tkinter as tk
import customtkinter as ctk
import os
import webbrowser
import tkinter.messagebox as messagebox
import logging
import socket
import platform
import time
import threading
import sys
import atexit
import tempfile
import portalocker
import psutil
import ctypes
from queue import Queue, Empty

def is_admin():
try:
return os.getuid() == 0
except AttributeError:
try:
return ctypes.windll.shell32.IsUserAnAdmin()
except:
return False

def run_as_admin():
if not is_admin():
script = os.path.abspath(sys.argv[0])
params = ' '.join([script] + sys.argv[1:])
# Requesting elevation
ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, params, None, 1)
sys.exit(0)

def is_valid_ip_address(ip_address):
"""
Validate if the given IP address is valid.

Args:
    ip_address (str): IP address to validate.

Returns:
    bool: True if valid, False otherwise.
"""
if ip_address.lower() == 'localhost':
    return True
try:
    # Try validating as an IPv4 address
    socket.inet_aton(ip_address)
    return ip_address.count('.') == 3
except socket.error:
    pass
try:
    # Try validating as an IPv6 address
    socket.inet_pton(socket.AF_INET6, ip_address)
    return True
except socket.error:
    return False

class ServerGUI(ctk.CTk):
"""
A GUI application to manage a server.

This class provides methods to start, stop, and refresh the server, 
and check its status and connectivity.

Attributes:
    lockfile (file): File object for the lock file.
    lock_file_path (str): Path to the lock file.
    server_start_time (float): Start time of the server.
    timer_thread (threading.Thread): Thread for updating the server running time.
    port (int): Port number on which the server runs.
    running (bool): Indicates if the server is running.
    server_process (subprocess.Popen): Process object for the server.
    collect_server_errors_thread (threading.Thread): Thread for collecting server errors.
    timer_queue (Queue): Queue to handle server running time updates.
    ip_address (str): IP address of the server.
    refreshing_server (bool): Indicates if the server is being refreshed.
    default_ip_used (bool): Indicates if the default IP address is used.
"""

def __init__(self):
    """
    Initialize the ServerGUI instance.
    """
    super().__init__()

    self.lockfile = None

    if getattr(sys, 'frozen', False):
        self.lock_file_path = os.path.join(sys._MEIPASS,  'my_app.lock')
    else:
        self.lock_file_path = os.path.join(tempfile.gettempdir(), 'my_app.lock')

    # Attempt to acquire the lock
    self.acquire_lock()

    self.setup_logging()
    self.initialize_attributes()
    self.configure_gui()
    self.create_widgets()
    self.setup_layout()

def setup_logging(self):
    """
    Set up logging for the application.
    """
    if getattr(sys, 'frozen', False):
        log_file_path = os.path.join(sys._MEIPASS, 'server_gui_log.log')
    else:
        log_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'server_gui_log.log')

    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', filename=log_file_path, filemode='a')
    logging.debug('Logging setup complete')
    logging.debug(f'Working directory: {os.getcwd()}')
    logging.debug(f'System path: {sys.path}')
    logging.debug(f'Environment variables: {os.environ}')

def initialize_attributes(self):
    """
    Initialize the attributes of the ServerGUI instance.
    """
    self.server_start_time = None
    self.timer_thread = None
    self.port = None
    self.running = False
    self.server_process = None
    self.collect_server_errors_thread = None
    self.timer_queue = Queue()

def configure_gui(self):
    """
    Configure the appearance of the GUI.
    """
    ctk.set_appearance_mode("Dark")
    ctk.set_default_color_theme("dark-blue")
    self.title('Dorm Server Starter')
    self.geometry('900x500')

def create_widgets(self):
    """
    Create the widgets for the GUI.
    """
    self.ip_frame = ctk.CTkFrame(self)
    self.ip_label = ctk.CTkLabel(self.ip_frame, text='IP Address:', font=("Arial", 15, "bold"), text_color="white")
    self.ip_input = ctk.CTkEntry(self.ip_frame, width=300, height=35, font=("Arial", 12))

    self.os_label = ctk.CTkLabel(self, text='Select your OS type (or auto-detect):', font=("Arial", 15, "bold"), text_color="white")
    self.os_frame = ctk.CTkFrame(self)
    self.os_var = tk.StringVar(value='Auto')
    self.os_auto = ctk.CTkRadioButton(self.os_frame, text='Auto', variable=self.os_var, value='Auto')
    self.os_windows = ctk.CTkRadioButton(self.os_frame, text='Windows', variable=self.os_var, value='Windows')
    self.os_linux = ctk.CTkRadioButton(self.os_frame, text='Linux', variable=self.os_var, value='Linux')

    self.button_frame = ctk.CTkFrame(self)
    self.default_button = ctk.CTkButton(self.button_frame, text='Use Default IP', command=self.use_default_ip, width=150, height=35, font=("Arial", 12))
    self.ip_button = ctk.CTkButton(self.button_frame, text='Get IP Address', command=self.get_ip_address, width=150, height=35, font=("Arial", 12))
    self.start_button = ctk.CTkButton(self.button_frame, text='Start Server', command=self.start_server, width=150, height=35, font=("Arial", 12), fg_color="green", hover_color="darkgreen")
    self.stop_button = ctk.CTkButton(self.button_frame, text='Stop Server', command=self.stop_server, width=150, height=35, font=("Arial", 12), fg_color="red", hover_color="darkred")
    self.refresh_button = ctk.CTkButton(self.button_frame, text='Refresh Server', command=self.refresh_server, width=150, height=35, font=("Arial", 12), fg_color="orange", hover_color="darkorange")
    self.check_listening_button = ctk.CTkButton(self.button_frame, text='Check Server Port Listening', command=self.check_server_listening, width=150, height=35, font=("Arial", 12))
    self.test_connection_button = ctk.CTkButton(self.button_frame, text='Test Server Connection', command=self.test_server_connection, width=150, height=35, font=("Arial", 12))
    self.ping_button = ctk.CTkButton(self.button_frame, text='Ping Server', command=self.ping_server, width=150, height=35, font=("Arial", 12))
    self.firewall_button = ctk.CTkButton(self.button_frame, text='Add Firewall Rule', command=self.add_firewall_rule, width=150, height=35, font=("Arial", 12))

    self.timer_label = ctk.CTkLabel(self, text='Server running time: 0s', font=("Arial", 15, "bold"))
    self.second_frame = ctk.CTkScrollableFrame(self, height=10, width=100)
    self.label_frame = ctk.CTkScrollableFrame(self.second_frame, height=10, width=100)

    self.status_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
    self.listening_status_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
    self.connection_listening_status_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
    self.ping_result_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
    self.firewall_result_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="yellow")
    self.output_label = ctk.CTkLabel(self.label_frame, text='', font=("Arial", 12), text_color="red")

    self.copy_url_textbox = tk.Text(self.second_frame, wrap='word', height=2, width=40, bg="black", fg="white", font=("Arial", 9))
    self.error_textbox = tk.Text(self.second_frame, wrap='word', height=10, width=100, bg="black", fg="red", font=("Arial", 9))

def setup_layout(self):
    """
    Set up the layout of the widgets in the GUI.
    """
    self.ip_frame.pack(pady=5)
    self.ip_label.grid(row=0, column=0, padx=5, pady=5)
    self.ip_input.grid(row=0, column=1, padx=5, pady=5)

    self.os_label.pack(pady=10)
    self.os_frame.pack(pady=5)
    self.os_auto.grid(row=0, column=0, padx=5, pady=5)
    self.os_windows.grid(row=0, column=1, padx=5, pady=5)
    self.os_linux.grid(row=0, column=2, padx=5, pady=5)

    self.button_frame.pack(pady=8)
    self.default_button.grid(row=0, column=0, padx=5, pady=5)
    self.ip_button.grid(row=0, column=1, padx=5, pady=5)
    self.start_button.grid(row=0, column=2, padx=5, pady=5)
    self.stop_button.grid(row=0, column=3, padx=5, pady=5)
    self.refresh_button.grid(row=1, column=0, padx=5, pady=5)
    self.check_listening_button.grid(row=1, column=1, padx=5, pady=5)
    self.test_connection_button.grid(row=1, column=2, padx=5, pady=5)
    self.ping_button.grid(row=1, column=3, padx=5, pady=5)
    self.firewall_button.grid(row=2, column=0, padx=5, pady=5)

    self.timer_label.pack(pady=4)
    self.second_frame.pack(pady=4, fill='both', expand=True)
    self.label_frame.pack(pady=2, fill='both', expand=True)

    self.status_label.pack(pady=2)
    self.listening_status_label.pack(pady=2)
    self.connection_listening_status_label.pack(pady=5)
    self.ping_result_label.pack(pady=2)
    self.firewall_result_label.pack(pady=2)
    self.output_label.pack(pady=2)

    self.copy_url_textbox.pack(pady=5)
    self.error_textbox.pack(pady=10)

def acquire_lock(self):
    """
    Acquire a file lock to ensure only one instance of the application is running.
    """
    self.lockfile = open(self.lock_file_path, 'w')
    try:
        portalocker.lock(self.lockfile, portalocker.LOCK_EX | portalocker.LOCK_NB)
    except portalocker.LockException:
        messagebox.showerror("Error", "Another instance of this application is already running.")
        self.lockfile.close()
        sys.exit(-1)  # Exit only this instance
    atexit.register(self.release_lock)

def release_lock(self):
    """
    Release the file lock upon application exit.
    """
    try:
        portalocker.unlock(self.lockfile)
    except Exception as e:
        logging.error(f"Error releasing file lock: {e}")
    self.lockfile.close()

def logout(self):
    """
    Exit the application.
    """
    try:
        sys.exit()
    except Exception as e:
        logging.error(f"Something went wrong while quitting app: {e}")
        self.quit()
        self.destroy()

def use_default_ip(self):
    """
    Use the default IP address (192.168.1.100) for the server.
    """
    if self.server_process and self.server_process.poll() is None:
        messagebox.showerror("Server Currently Running", "A server is currently running. You don't need another IP address")
        return
    else:
        self.ip_address = '192.168.1.100'  # Ensure self.ip_address is set
        self.ip_input.delete(0, ctk.END)
        self.ip_input.insert(0, self.ip_address)
        messagebox.showwarning("Default IP - Network congiguration Required", "Kindly ensure the default IP address: '192.168.1.100' communicates on your network\nAnd not currently in use by another service.")
        self.status_label.configure(text='Using default IP address: 192.168.1.100')
        self.default_ip_used = True  # Track if the default IP is used

def get_ip_address(self):
    """
    Get and set the IP address for the server.
    """
    if self.server_process and self.server_process.poll() is None:
        messagebox.showerror("Server Currently Running", "A server is currently running. You don't need another IP address")
        return
    else:
        if hasattr(self, 'default_ip_used') and self.default_ip_used:
            self.default_ip_used = False
            self.ip_address = ' '  # Ensure self.ip_address is cleared 
        else:
            self.ip_address = self.detect_ip_address()  # Ensure self.ip_address is set

        self.ip_input.delete(0, ctk.END)
        self.ip_input.insert(0, self.ip_address)
        self.status_label.configure(text=f'IP address detected: {self.ip_address}')

def detect_ip_address(self):
    """
    Detect the IP address of the current machine.

    Returns:
        str: Detected IP address.
    """
    os_type = platform.system()

    retries = 3
    for attempt in range(retries):
        try:
            if os_type in ['Windows', 'Linux', 'Darwin']:
                preferred_interfaces = ['Wi-Fi', 'Ethernet', 'eth0', 'wlan0']

                # Get all network interfaces and their stats
                interfaces = psutil.net_if_addrs()
                interface_stats = psutil.net_if_stats()

                # First, try to find a preferred interface with a valid IPv4 address and is up
                for interface in preferred_interfaces:
                    if interface in interfaces and interface_stats[interface].isup:
                        for addr in interfaces[interface]:
                            if addr.family == socket.AF_INET and not addr.address.startswith("127."):
                                return addr.address

                # If no preferred interface found, look for any non-loopback IPv4 address that is up
                for interface, addrs in interfaces.items():
                    if interface_stats[interface].isup:
                        for addr in addrs:
                            if addr.family == socket.AF_INET and not addr.address.startswith("127."):
                                return addr.address
            else:
                raise ValueError("Unsupported OS type for IP detection.")
        except Exception as e:
            logging.error(f'Error detecting IP address: {e}')
            time.sleep(1)
            
    messagebox.showinfo("No Reachable IP Address", "There's no reachable IP Address because you're not connected to any network so it fallback to the default IP Address.\nKindly ensure you've configured your network to communicate on the default IP address: '192.168.1.100'")
    # Fallback to loopback address if no valid IP found
    return '192.168.1.100'

def start_server(self):
    """
    Start the server.
    """
    if self.server_process and self.server_process.poll() is None:
        messagebox.showerror("Server Currently Running", "You can't start another server while one server is currently running")
        return

    if hasattr(self, 'refreshing_server') and self.refreshing_server:
        self.ip_address = self.ip_input.get() if self.ip_input.get() != "" else '192.168.1.100'
        threading.Thread(target=self.start_server_thread).start()
        self.refreshing_server = False
    else:
        self.ip_address = self.ip_input.get() or '192.168.1.100'

        if not is_valid_ip_address(self.ip_address):
            messagebox.showerror("Invalid IP Address", "The provided IP address is not valid.")
            self.status_label.configure(text='Invalid IP address provided', text_color='red')
            self.title('Dorm Server Starter - Invalid IP address')
            return

        if self.ip_address == '192.168.1.100':
            confirm = messagebox.askquestion("Confirm Starting Server at '192.168.1.100'", "Are you sure you want to start the server at '192.168.1.100'?")
            if confirm != 'yes':
                messagebox.showerror("Choose an IP Address", "Kindly input your desired correct local IP address or use the Get IP Address button")
                self.status_label.configure(text='No Server is currently running')
                self.title('Dorm Server Starter - No Server is currently running')
                return

        # Start the server in a new thread
        threading.Thread(target=self.start_server_thread).start()

def start_server_thread(self):
    """
    Thread target to start the server process.
    """
    try:
        self.port = 8000
        
        self.threads = 6

        self.update_status(f'Starting server at IP address: {self.ip_address} on port {self.port}')
        self.title('Dorm Server Starter - Server is Starting.......')
        self.show_info("Server Status", "Server is starting.......")

        env = os.environ.copy()
        env["RUNNING_SERVER"] = "1"
        env["DJANGO_SETTINGS_MODULE"] = 'cbt.settings'
        env['LOCAL_IP_ADDRESS'] = self.ip_address
        env['PORT'] = str(self.port)

        logging.debug(f'Environment before starting server: {env}')

        if getattr(sys, 'frozen', False):
            server_script_file_path = os.path.join(sys._MEIPASS, 'start_waitress.py')
        else:
            server_script_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'start_waitress.py')

        logging.debug(f'Server script file path: {server_script_file_path}')

        creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == 'nt' else 0

        # Ensure no lingering processes are using the IP and port before starting a new one
        self.find_and_terminate_processes(self.ip_address, self.port)
        
        logging.debug(f"Arguments for server process: {sys.executable} --run-server {server_script_file_path} {self.ip_address} {self.port}")
        
        # Initial attempt
        if getattr(sys, 'frozen', False):
            logging.debug(f"Running frozen app with: {sys.executable}, --run-server, {server_script_file_path}, {self.ip_address}, {str(self.port)}")
            self.server_process = subprocess.Popen(
                [sys.executable, '--run-server', server_script_file_path, self.ip_address, str(self.port), str(self.threads)],
                env=env, creationflags=creationflags,
                stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                cwd=os.path.dirname(server_script_file_path),
            )
        else:
            logging.debug(f"Running non-frozen app with: {sys.executable}, {server_script_file_path}, {self.ip_address}, {str(self.port)}")
            self.server_process = subprocess.Popen(
                [sys.executable, server_script_file_path, self.ip_address, str(self.port), str(self.threads)],
                env=env, creationflags=creationflags,
                stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                cwd=os.path.dirname(server_script_file_path),
            )

        time.sleep(40)  # Short delay to let the process start and potentially fail

        # Check if the initial attempt failed
        if self.server_process.poll() is not None:
            exit_code = self.server_process.returncode
            self.handle_start_failure(server_script_file_path=server_script_file_path, env=env, creationflags=creationflags, exit_code=exit_code)
        else:
            # Enhanced check to verify server connection
            if self.is_server_responding():
                logging.debug(f"Server process started with PID: {self.server_process.pid}")
                self.finalize_successful_start()
            else:
                exit_code = self.server_process.returncode
                self.handle_start_failure(server_script_file_path=server_script_file_path, env=env, creationflags=creationflags, exit_code=exit_code)

    except Exception as e:
        self.update_status(f'Error starting server: {e}', 'yellow')
        self.show_error("Server Error", f"Error starting server: {e}")
        logging.error(f"Error starting server: {e}")
        self.title('Dorm Server Starter - Error')

def handle_start_failure(self, server_script_file_path, env, creationflags, exit_code):
    """
    Handle server start failure by retrying.
    """
    retries = 3
    for attempt in range(retries):
        try:
            print(f"Retry attempt {attempt + 1} with exit code: {exit_code}")
            if exit_code == 1:
                self.update_status(f'OSError: Ensure you have permissions to bind to the port and/or your IP Address is reachable\nand not currently in use by another service on your network.', 'red')
                messagebox.showerror("OSError: Server Failed", '''OSError: Please ensure you're connected to a network and/or your IP Address is reachable\nand not currently in use by another service on your network.\nEnsure you have permissions to bind to the port: 8000.''')
            elif exit_code == None:
                self.update_status(f'OSError: Ensure you have permissions to bind to the port and/or your IP Address is reachable\nand not currently in use by another service on your network.', 'red')
                messagebox.showerror("OSError: Server Failed", '''OSError: Please ensure you're connected to a network and/or your IP Address is reachable\nand not currently in use by another service on your network.\nEnsure you have permissions to bind to the port: 8000.''')
            elif exit_code == 2:
                self.update_status(f'General Error: Error starting the server', 'red')
                messagebox.showerror("Waitress Error", "Error starting waitress server")
            elif exit_code == 15:
                self.update_status(f'Process was terminated. Possible SIGTERM signal.', 'red')
                messagebox.showerror("Process Terminated", "The server process was terminated unexpectedly. Exit code 15 (SIGTERM).")
            else:
                self.update_status(f'Unknown Error: Server process exited with code {exit_code}', 'red')

            logging.error(f"Server process failed to start with exit code {exit_code}")
            logging.warning(f'Server start attempt {attempt + 1} failed. Retrying...')
            self.update_status(f'Server start attempt {attempt + 1} failed. Retrying...', 'yellow')

            self.server_process = subprocess.Popen(
                [sys.executable, server_script_file_path, self.ip_address, str(self.port), "6"],
                env=env, creationflags=creationflags,
                stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                cwd=os.path.dirname(server_script_file_path),
            )

            time.sleep(50)  # Short delay to let the process start and potentially fail
            
            # Ensure any lingering subprocess is terminated before starting a new one
            self.find_and_terminate_processes(self.ip_address, self.port)

            # Check the exit code after the retry attempt
            if self.server_process.poll() is not None:
                exit_code = self.server_process.returncode
                print(f"The exit code from handle_start_failure method: {exit_code}")
                raise Exception("Server process failed to start")

            if self.is_server_responding():
                self.finalize_successful_start()
                break  # Exit the loop if the server started successfully

        except Exception as e:
            logging.error(f"Retry {attempt + 1} failed: {e}")
            if attempt < retries - 1:
                time.sleep(2)  # Wait before retrying
            else:
                self.update_status(f"Server process failed to start after three (3) attempts - KINDLY RESTART SERVER", 'red')
                self.title(f'Dorm Server Starter - Server failed to connect at: http://{self.ip_address}:{self.port}/')
                messagebox.showerror("Server Failed...", "Server process failed to start after three (3) attempts - Kindly Restart Server")

def finalize_successful_start(self):
    """
    Finalize the server start process after a successful attempt.
    """
    if self.server_process and self.server_process.poll() is None and self.server_process.stderr:
        self.collect_server_errors_thread = threading.Thread(target=self.collect_server_errors)
        self.collect_server_errors_thread.start()

    if self.server_process and self.server_process.poll() is None:
        self.update_status(f'Server running at IP address: {self.ip_address} on port {self.port}', 'green')
        self.title(f'Dorm Server Starter - Server running at: http://{self.ip_address}:{self.port}/')
        self.update_copy_url_textbox(f'Copy your URL: http://{self.ip_address}:{self.port}/')
        self.show_info("Server Status", "The server has started")

        logging.debug(f'Environment variables after the server has started: {os.environ}')
        logging.debug(f"Server process PID after server has started: {self.server_process.pid}")

        self.running = True
        self.server_start_time = time.time()
        self.timer_thread = threading.Thread(target=self.update_timer)
        self.timer_thread.start()
        self.check_timer_queue()

        webbrowser.open(f'http://{self.ip_address}:{self.port}/')

def is_server_responding(self):
    """
    Check if the server is responding by attempting to open a socket connection.
    """
    try:
        with socket.create_connection((self.ip_address, self.port), timeout=5) as sock:
            sock.shutdown(socket.SHUT_RDWR)
            return True
    except (socket.timeout, ConnectionRefusedError, OSError):
        return False
        
def update_status(self, message, color='yellow'):
    """
    Update the status label in the GUI.

    Args:
        message (str): The status message to display.
        color (str): The color of the status message.
    """
    self.after(0, lambda: self.status_label.configure(text=message, text_color=color))

def show_info(self, title, message):
    """
    Show an informational message box.

    Args:
        title (str): The title of the message box.
        message (str): The message to display.
    """
    self.after(0, lambda: messagebox.showinfo(title, message))

def show_error(self, title, message):
    """
    Show an error message box.

    Args:
        title (str): The title of the message box.
        message (str): The message to display.
    """
    self.after(0, lambda: messagebox.showerror(title, message))

def update_copy_url_textbox(self, url):
    """
    Update the URL textbox in the GUI.

    Args:
        url (str): The URL to display.
    """
    self.after(0, lambda: self.copy_url_textbox.insert(tk.END, url))
    self.after(0, lambda: self.copy_url_textbox.see(tk.END))

def update_error_textbox(self, message):
    """
    Update the error textbox in the GUI.

    Args:
        message (str): The error message to display.
    """
    self.after(0, lambda: self.error_textbox.insert(tk.END, message))
    self.after(0, lambda: self.error_textbox.see(tk.END))

def stop_server(self):
    """
    Stop the server.
    """
    if self.server_process and self.server_process.poll() is None:
        if hasattr(self, 'refreshing_server') and self.refreshing_server:
            self.status_label.configure(text='Refreshing server...', text_color='yellow')
            self.title('Dorm Server Starter - Refreshing server...')
            self.running = False
            # Start a thread to terminate the server process
            threading.Thread(target=self.terminate_server_process).start()
        else:
            confirm = messagebox.askquestion("Confirm Exit", "Are you sure you want to stop the server?")
            if confirm == 'yes':
                self.status_label.configure(text='Stopping server...')
                self.title('Dorm Server Starter - Terminating server...')
                self.running = False
                # Start a thread to terminate the server process
                threading.Thread(target=self.terminate_server_process).start()
            else:
                self.status_label.configure(text=f'Server running at IP address: {self.ip_address}')
                self.title(f'Dorm Server Starter - Server running at: {self.ip_address}')
    else:
        self.status_label.configure(text='No server running')
        messagebox.showwarning("Server Status", "No server is currently running")
        self.title('Dorm Server Starter - No Server Running')
        confirm = messagebox.askquestion("Server Status - No server is currently running", "Would you like to quit?")
        if confirm == 'yes':
            self.logout()  # Quit the Tkinter main loop

def terminate_server_process(self):
    """
    Terminate the server process and ensure the server connection is properly shut down.
    """
    try:
        if self.timer_thread:
            self.timer_thread.join()
        if self.collect_server_errors_thread:
            self.collect_server_errors_thread.join()

        # Terminate the server process
        if self.server_process and self.server_process.poll() is None:
            logging.info("Terminating the server process.")
            self.server_process.terminate()
            try:
                self.server_process.wait(timeout=5)
            except subprocess.TimeoutExpired:
                logging.warning("Server process did not terminate in time. Forcing kill.")
                self.server_process.kill()
                self.server_process.wait()

        # Ensure the server socket is closed
        self.close_server_connection()

        if hasattr(self, 'refreshing_server') and self.refreshing_server:
            messagebox.showinfo("Dorm Server Refresh", 'The server has terminated, the server will refresh now')
            self.after(200, self.start_server)
        else:
            messagebox.showinfo("Dorm Server Starter", 'The server has terminated, the app will Exit now')
            self.after(100, self.logout)  # Schedule the logout method to be called after a short delay

    except Exception as e:
        logging.error(f"The server process didn't terminate properly: {e}")
        self.server_process.kill()
        self.server_process.wait()
        self.close_server_connection()
        self.after(100, self.logout)  # Schedule the logout method to be called after a short delay

def close_server_connection(self):
    """
    Close the server connection explicitly.
    """
    try:
        logging.info("Attempting to close the server connection...")

        # Create a connection to the server to close it
        with socket.create_connection((self.ip_address, self.port), timeout=5) as sock:
            logging.info("Connection established. Shutting down the server connection.")
            sock.shutdown(socket.SHUT_RDWR)
            sock.close()
        logging.info("Server connection closed successfully.")
        
    except (socket.timeout, ConnectionRefusedError, OSError) as e:
        logging.info(f"Server connection already closed or could not be established: {e}")    
    
    # Ensure no lingering processes are using the IP and port
    self.find_and_terminate_processes(self.ip_address, self.port)

    # Ensure all related processes are terminated
    if self.server_process and self.server_process.poll() is None:
        logging.info(f"Terminating server process with PID: {self.server_process.pid}")
        self.server_process.terminate()
        try:
            self.server_process.wait(timeout=5)
        except subprocess.TimeoutExpired:
            logging.warning("Server process did not terminate in time. Forcing kill.")
            self.server_process.kill()
            self.server_process.wait()

    # Ensure all child processes are terminated
    if self.server_process:
        try:
            parent_process = psutil.Process(self.server_process.pid)
            children = parent_process.children(recursive=True)
            for child in children:
                logging.info(f"Terminating child process with PID: {child.pid}")
                child.terminate()
                try:
                    child.wait(timeout=5)
                except psutil.TimeoutExpired:
                    logging.warning(f"Child process with PID {child.pid} did not terminate in time. Forcing kill.")
                    child.kill()
        except psutil.NoSuchProcess:
            logging.info("Parent process does not exist anymore.")

    logging.info("Server connection cleanup completed.")     
    
def find_and_terminate_processes(self, ip, port):
    """
    Find and terminate any processes that are listening on the given IP address and port.
    """
    try:
        # Get all current connections
        connections = psutil.net_connections(kind='inet')

        for conn in connections:
            # Check if the connection matches the IP and port
            if conn.laddr.ip == ip and conn.laddr.port == port:
                logging.info(f"Found lingering process with PID {conn.pid} on {ip}:{port}")
                try:
                    # Get the process using the connection's PID
                    proc = psutil.Process(conn.pid)
                    logging.info(f"Terminating process {proc.pid} ({proc.name()})")
                    proc.terminate()
                    try:
                        proc.wait(timeout=5)
                        logging.info(f"Terminated process {proc.pid} ({proc.name()})")
                    except psutil.TimeoutExpired:
                        logging.warning(f"Process {proc.pid} did not terminate in time. Forcing kill.")
                        proc.kill()
                        proc.wait()
                except psutil.NoSuchProcess:
                    logging.info(f"Process {conn.pid} no longer exists.")
    except Exception as e:
        logging.error(f"Error finding and terminating processes: {e}")

def refresh_server(self):
    """
    Refresh the server by stopping and restarting it.
    """
    if self.server_process and self.server_process.poll() is None:
        try:
            confirm = messagebox.askquestion("Confirm Restart", "Are you sure you want to refresh the server?")
            if confirm == 'yes':
                self.refreshing_server = True  # Track if it is refreshing server
                self.stop_server()  # Stop the server, which will internally call terminate_server_process
            else:
                self.status_label.configure(text=f'Server running at IP address: {self.ip_address} on port {self.port}')
                self.title(f'Dorm Server Starter - Server running at: {self.ip_address}')
        except Exception as e:
            logging.error(f"There was an error refreshing the server: {e}")
            self.refreshing_server = False  # Turn False for refreshing server
            self.status_label.configure(text=f'Error refreshing server on: {self.ip_address} on port {self.port}', text_color='red')
            return
    else:
        self.status_label.configure(text='No server running to refresh')
        messagebox.showwarning("Server Status", "No server is currently running")
        self.title('Dorm Server Starter - No Server Running')
        return

def collect_server_errors(self):
    """
    Collect errors from the server's stderr stream.
    """
    try:
        # Continuously collect server errors as long as the server is running
        while self.running and self.server_process and self.server_process.stderr:
            try:
                for line in iter(self.server_process.stderr.readline, b''):
                    self.error_textbox.insert(tk.END, line.decode())
                    self.error_textbox.see(tk.END)
                    logging.error(line.decode())
                self.server_process.stderr.close()
            except ValueError:
                logging.error("Attempted to read from a closed stderr stream.")
                break
    except Exception as e:
        logging.error(f"Error collecting server errors: {e}")

def update_timer(self):
    """
    Update the timer label with the elapsed time since the server started.
    """
    # Update the timer label with the elapsed time since the server started
    while self.running:
        if self.server_start_time:
            elapsed_time = int(time.time() - self.server_start_time)
            self.timer_queue.put(elapsed_time)
            time.sleep(1)

def check_timer_queue(self):
    """
    Check the queue for the latest elapsed time and update the timer label.
    """
    try:
        # Check the queue for the latest elapsed time and update the timer label
        elapsed_time = self.timer_queue.get_nowait()
        self.timer_label.configure(text=f'Server running time: {elapsed_time}s')
    except Empty:
        pass
    # Schedule the next check
    self.after(1000, self.check_timer_queue)

def check_server_listening(self):
    """
    Check if the server is listening on the specified port.
    """
    if self.server_process and self.server_process.poll() is None:
        port = self.port
        os_type = platform.system().lower()
        cmd = []

        if os_type == 'windows':
            cmd = ['netstat', '-an']
        elif os_type in ['linux', 'darwin']:
            cmd = ['ss', '-an']
        else:
            self.listening_status_label.configure(text=f'Unsupported OS for checking listening ports', text_color='red')
            return

        try:
            if os.name == 'nt':
                # Set up the startup info to prevent the console window from appearing
                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                
                result = subprocess.run(cmd, capture_output=True, text=True, startupinfo=startupinfo)
            if result.returncode != 0:
                raise subprocess.CalledProcessError(result.returncode, cmd, output=result.stdout, stderr=result.stderr)

            output = result.stdout.lower()
            listening = any(f'tcp' in line and f':{port}' in line for line in output.splitlines())

            if listening:
                self.listening_status_label.configure(text=f'Server is listening on port {port}', text_color='green')
            else:
                self.listening_status_label.configure(text=f'Server is not listening on port {port}', text_color='red')

        except Exception as e:
            self.listening_status_label.configure(text=f'Error checking server listening: {e}', text_color='red')
            logging.error(f'Error checking server listening: {e}')
    else:
        messagebox.showerror('No server to listen', 'There is no server running to listen')

def test_server_connection(self):
    """
    Test the connection to the server.
    """
    if self.server_process and self.server_process.poll() is None:
        url = f'http://{self.ip_address}:{self.port}'
        os_type = platform.system().lower()
        cmd = []

        if os_type == 'windows':
            cmd = ['curl', '-s', '-o', 'NUL', '-w', '%{http_code}', url]
        elif os_type in ['linux', 'darwin']:
            cmd = ['wget', '-q', '--spider', '--server-response', url]
        else:
            self.connection_listening_status_label.configure(text=f'Unsupported OS for testing connection', text_color='red')
            return

        try:
            if os.name == 'nt':
                # Set up the startup info to prevent the console window from appearing
                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

                result = subprocess.run(cmd, capture_output=True, text=True, startupinfo=startupinfo)
            else:
                result = subprocess.run(cmd, capture_output=True, text=True)

            if result.returncode == 0:
                self.connection_listening_status_label.configure(text=f'Successfully connected to {url}', text_color='green')
            else:
                self.connection_listening_status_label.configure(text=f'Failed to connect to {url}: {result.stderr}', text_color='red')
                logging.error(f'Failed to connect to {url}: {result.stderr}')
        except Exception as e:
            self.connection_listening_status_label.configure(text=f'Error testing server connection: {e}', text_color='red')
            logging.error(f'Error testing server connection: {e}')
    else:
        messagebox.showerror('No server to check connection', 'There is no server running to check connection')

def ping_server(self):
    """
    Ping the server to check its reachability.
    """
    try:
        ip_address = self.ip_input.get() or '192.168.1.100'
        result = ping_server(ip_address)
        self.ping_result_label.configure(text=result)
    except Exception as e:
        self.status_label.configure(text=f'There was error trying to ping address: {e}')
        self.title("Dorm Server Starter - Error - Can't ping")
        

def add_firewall_rule(self):
    """
    Add firewall rules for the server.
    """
    ask_permission = messagebox.askyesno('Permission Required', 'Did you run the app as an administrator?')
    if ask_permission:
        if self.server_process and self.server_process.poll() is None:
            port = self.port or 8000
            os_type = platform.system().lower()
            if os_type == 'windows':
                result = add_firewall_rule_windows(port)
            elif os_type == 'linux':
                result = add_firewall_rule_linux(port)
            elif os_type == 'darwin':
                result = add_firewall_rule_macos(port)
            else:
                result = f'Unsupported OS for adding firewall rule'
            self.error_textbox.insert(tk.END, result)
            self.error_textbox.see(tk.END)
        else:
            self.status_label.configure(text='No server running to add firewall rules for')
            messagebox.showerror("Server Status", "No server is currently running - Can't add firewall rules")
            self.title("Dorm Server Starter - No Server Running - Can't add firewall rules")
    else:
        messagebox.showerror("Permission Required", "Administrative permission required to perform this task!")
        return 

def add_firewall_rule_windows(port):
"""
Add firewall rules for Windows OS.

Args:
    port (int): Port number for which to add the firewall rules.

Returns:
    str: Result message indicating success or failure.
"""
try:
    # Set up the startup info to prevent the console window from appearing
    startupinfo = subprocess.STARTUPINFO()
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    subprocess.run(["netsh", "advfirewall", "firewall", "add", "rule", 
                    "name=AllowPort{}".format(port), 
                    "dir=in", "action=allow", "protocol=TCP", 
                    "localport={}".format(port)], check=True, startupinfo=startupinfo)
    subprocess.run(["netsh", "advfirewall", "firewall", "add", "rule", 
                    "name=AllowPort{}".format(port), 
                    "dir=out", "action=allow", "protocol=TCP", 
                    "localport={}".format(port)], check=True, startupinfo=startupinfo)
    return "Firewall rules added successfully for port {}".format(port)
except subprocess.CalledProcessError as e:
    return "Error adding firewall rule: {}".format(e)

def add_firewall_rule_linux(port):
"""
Add firewall rules for Linux OS.

Args:
    port (int): Port number for which to add the firewall rules.

Returns:
    str: Result message indicating success or failure.
"""
try:
    # Set up the startup info to prevent the console window from appearing
    startupinfo = subprocess.STARTUPINFO()
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    subprocess.run(["sudo", "iptables", "-A", "INPUT", "-p", "tcp", "--dport", str(port), "-j", "ACCEPT"], check=True, startupinfo=startupinfo)
    subprocess.run(["sudo", "iptables", "-A", "OUTPUT", "-p", "tcp", "--dport", str(port), "-j", "ACCEPT"], check=True, startupinfo=startupinfo)
    return "Firewall rules added successfully for port {}".format(port)
except subprocess.CalledProcessError as e:
    return "Error adding firewall rule: {}".format(e)

def add_firewall_rule_macos(port):
"""
Add firewall rules for MacOS.

Args:
    port (int): Port number for which to add the firewall rules.

Returns:
    str: Result message indicating success or failure.
"""
try:
    # Set up the startup info to prevent the console window from appearing
    startupinfo = subprocess.STARTUPINFO()
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    rule = "pass in proto tcp from any to any port {}".format(port)
    subprocess.run(["echo", rule, "|", "sudo", "pfctl", "-f", "-"], shell=True, check=True, startupinfo=startupinfo)
    subprocess.run(["sudo", "pfctl", "-e"], check=True, startupinfo=startupinfo)
    return "Firewall rules added successfully for port {}".format(port)
except subprocess.CalledProcessError as e:
    return "Error adding firewall rule: {}".format(e)

def ping_server(ip_address):
"""
Ping a server to check its reachability.

Args:
    ip_address (str): IP address of the server to ping.

Returns:
    str: Result message indicating success or failure of the ping.
"""
param = '-n' if platform.system().lower() == 'windows' else '-c'
command = ['ping', param, '4', ip_address]

try:
    # Set up the startup info to prevent the console window from appearing
    startupinfo = subprocess.STARTUPINFO()
    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    output = subprocess.check_output(command, universal_newlines=True, startupinfo=startupinfo)
    return output
except subprocess.CalledProcessError as e:
    messagebox.showerror("Error - Ping Failed", "Ping failed due to: {}".format(e))
    return "Ping failed: {}".format(e)

def run_main_application():
if "GUI_ALREADY_RUNNING" not in os.environ:
os.environ["GUI_ALREADY_RUNNING"] = "1"
app = ServerGUI()
app.mainloop()

def main():
if len(sys.argv) > 1 and sys.argv[1] == '--run-server':
# Execute the server script
server_script_path = sys.argv[2]
server_ip = sys.argv[3]
server_port = int(sys.argv[4])
threads = int(sys.argv[5])

    print(f"IP address in def main(): {server_ip}")
    print(f"Port in def main(): {server_port}")
    print(f"Threads in def mian(): {threads}")
    
    logging.debug(f'IP address in main(): {server_ip}')
    logging.debug(f'Port in main(): {server_port}')
    logging.debug(f'Threads in mian(): {threads}')
    
    logging.debug(f'Running server with script: {server_script_path}, IP: {server_ip}, Port: {server_port}, threads: {threads}')
    
    with open(server_script_path) as f:
        code = f.read()
    exec(code, {'__name__': '__main__', 'sys': sys, 'os': os, 'ip_address': server_ip, 'port': server_port, 'threads': threads})
else:
    # The regular entry point for your main application
    run_main_application()

if name == 'main':
run_as_admin()
main()

The .spec file:

-- mode: python ; coding: utf-8 --

import os
import sys
import pkg_resources
from PyInstaller.utils.hooks import collect_all
import logging

if getattr(sys, 'frozen', False):
log_file_path = os.path.join(sys._MEIPASS, 'spec_log.log')
else:
log_file_path = os.path.join(os.path.dirname(os.path.abspath(name)), 'spec_log.log')

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', filename=log_file_path, filemode='a')

block_cipher = None

spec_file_dir = os.path.abspath('.')
requirements_path = os.path.join(spec_file_dir, 'requirements.txt')

with open(requirements_path) as f:
required_packages = [line.split('==')[0].replace('-', '_') for line in f.read().splitlines() if line and not line.startswith('#')]

customtkinter_datas, customtkinter_binaries, customtkinter_hiddenimports = collect_all('customtkinter')

installed_packages = [dist.project_name.replace('-', '_') for dist in pkg_resources.working_set]

logging.debug(f"Installed packages: {installed_packages}")

invalid_imports = ['pyinstaller_hooks_contrib']
valid_hiddenimports = [pkg for pkg in installed_packages if pkg not in invalid_imports]

logging.debug(f"Valid hidden imports: {valid_hiddenimports}")

datas = [
('cbt', 'cbt'),
('db.sqlite3', '.'),
('staticfiles/', 'staticfiles'),
('prominent/', 'prominent'),
('node_modules/', 'node_modules'),
('collectstatic/', 'collectstatic'),
('manage.py', '.'),
('migrate/', '.'),
('build_css/', '.'),
('migrations/', '.'),
('package.json', '.'),
('package-lock.json', '.'),
('run', '.'),
('tailwind.config.js', '.'),
('server_gui.py', '.'),
('pyinstaller_log.log', '.'),
('server_waitress_log.log', '.'),
('server_gui_log.log', '.'),
('start_waitress.py', '.'),
] + customtkinter_datas

hiddenimports = customtkinter_hiddenimports + required_packages + valid_hiddenimports + [
'altgraph', 'asgiref', 'certifi', 'charset_normalizer', 'contourpy',
'crispy_tailwind', 'cycler', 'darkdetect', 'django', 'django_crispy_forms',
'et_xmlfile', 'fonttools', 'idna', 'kiwisolver', 'lxml', 'matplotlib',
'numpy', 'openpyxl', 'packaging', 'pandas', 'pillow',
'pyparsing', 'python_dateutil', 'python_docx', 'pytz', 'requests', 'six',
'sqlparse', 'typing_extensions', 'tzdata', 'win32com',
'win32com.client', 'urllib3', 'whitenoise', 'XlsxWriter', 'waitress', 'whitenoise.middleware',
'customtkinter', 'portalocker', 'setuptools', 'ctypes', 'socket', 'threading', 'subprocess', 'os',
'sys', 'logging',
]

a = Analysis(
['server_gui.py'],
pathex=['.'],
binaries=[],
datas=datas,
hiddenimports=hiddenimports,
hookspath=['.'],
runtime_hooks=['hooks/dorm_runtime_hook.py'],
excludes=[],
win_no_prefer_redirects=False,
win_private_assemblies=False,
cipher=block_cipher,
noarchive=False,
)
pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)

exe = EXE(
pyz,
a.scripts,
[],
exclude_binaries=True,
name='Dorm',
debug=False,
bootloader_ignore_signals=False,
strip=False,
upx=False,
console=False,
bundle_files=1
)

coll = COLLECT(
exe,
a.binaries,
a.zipfiles,
a.datas,
strip=False,
upx=False,
name='Dorm'
)

The start_waitress.py script:
#!/env/python

import logging
import sys
import os
from waitress import serve
from cbt.wsgi import application
import socket

def run_server():
# Set up logging
log_file_path = os.path.join(os.path.dirname(os.path.abspath(name)), 'server_waitress_log.log')

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', filename=log_file_path, filemode='a')

# Log initial details
logging.debug('Starting waitress server with the following details:')
logging.debug(f'Current working directory: {os.getcwd()}')
logging.debug(f'Contents of the current directory: {os.listdir(".")}')
logging.debug(f'System path: {sys.path}')
logging.debug(f'Environment variables: {os.environ}')

# Get server parameters from command line arguments
if len(sys.argv) > 1:
    ip_address = sys.argv[1]
else:
    logging.error("IP address argument missing")
    sys.exit(1)

try:
    port = int(sys.argv[2])
except (IndexError, ValueError):
    logging.error("Port argument missing or invalid")
    sys.exit(1)
    
threads = int(sys.argv[3]) if len(sys.argv) > 3 else 6

logging.debug(f'IP address: {ip_address}')
logging.debug(f'Port: {port}')
logging.debug(f'Threads: {threads}')

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'cbt.settings')
os.environ['LOCAL_IP_ADDRESS'] = ip_address

# Validate IP address
try:
    socket.inet_aton(ip_address)
except socket.error:
    logging.error(f"Invalid IP address: {ip_address}")
    sys.exit(1)

try:
    logging.debug('Starting the server with waitress...')
    serve(application, host=ip_address, port=port, threads=threads)
    
    # Enhanced check to verify server connection
    if not is_server_responding(ip_address, port):
        logging.error("Server is not responding after start.")
        sys.exit(1)
except OSError as os_err:
    logging.error(f"OSError: {os_err}")
    logging.error("Make sure you have the necessary permissions to bind to the port.")
    sys.exit(1)  # Exit with code 1 for OSError
except Exception as e:
    logging.error(f"Error starting waitress server: {e}")
    sys.exit(2)  # Exit with code 2 for general errors

def is_server_responding(ip, port):
"""
Check if the server is responding by attempting to open a socket connection.
"""
try:
with socket.create_connection((ip, port), timeout=5) as sock:
sock.shutdown(socket.SHUT_RDWR)
return True
except (socket.timeout, ConnectionRefusedError, OSError):
return False

if name == 'main':
run_server()

I really need help on what to do and if I have complicated it due to my own ignorance.

[rokm]

What could be the problem?

Without seeing any code or error message, our guess is as good as yours.

    console=False,

Try building with console enabled, run from command prompt, and see if you get any warnings or other messages that will give you the hint on what is (not) going on.

    ('manage.py', '.'),

So if I understand correctly, your frozen application is just a GUI wrapper that manages the django application. How exactly is the django application launched, then? Does waitress use sys.executable and attempt to run manage.py? That definitely won't work out-of-the-box in PyInstaller-frozen application, as sys.execuable does not point to a python interpreter...

[Poltergeist1717]

No, what I did was that I have a script that runs the waitress in a file situated in the same folder as the app and manage.py using a subprocess. I have updated the question to show my server_gui.py code. There was no particular error displayed, the app was created successfully but the server won't connect. This wasn't an issue when I run it from the terminal.

[rokm]

See the comment in above thread.