pyproxytools 0.4.4__tar.gz → 0.4.6__tar.gz

{pyproxytools-0.4.4/pyproxytools.egg-info → pyproxytools-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyproxytools
-Version: 0.4.4
+Version: 0.4.6
 Summary: Lightweight and fast python web proxy
 Author: pyproxytools
 License-Expression: MIT

{pyproxytools-0.4.4 → pyproxytools-0.4.6}/pyproxy/__init__.py

@@ -5,7 +5,7 @@ that holds the current version number of the application.
 
 import os
 
-__version__ = "0.4.4"
+__version__ = "0.4.6"
 
 if os.path.isdir("pyproxy/monitoring"):
     __slim__ = False

{pyproxytools-0.4.4 → pyproxytools-0.4.6}/pyproxy/handlers/client.py

@@ -90,24 +90,25 @@ class ProxyHandlers:
         Args:
             client_socket (socket): The socket object for the client connection.
         """
-        request = client_socket.recv(4096)
+        try:
+            client_socket.settimeout(10)
+            request = client_socket.recv(4096)
 
-        if not request:
-            self.console_logger.debug("No request received, closing connection.")
+            if not request:
+                return
+
+            first_line = request.decode(errors="ignore").split("\n")[0]
+            if first_line.startswith("CONNECT"):
+                https_handler = self._create_handler(
+                    HttpsHandler,
+                    ssl_config=self.ssl_config,
+                    cancel_inspect_queue=self.cancel_inspect_queue,
+                    cancel_inspect_result_queue=self.cancel_inspect_result_queue,
+                )
+                https_handler.handle_https_connection(client_socket, first_line)
+            else:
+                http_handler = self._create_handler(HttpHandler)
+                http_handler.handle_http_request(client_socket, request)
+        finally:
             client_socket.close()
             self.active_connections.pop(threading.get_ident(), None)
-            return
-
-        first_line = request.decode(errors="ignore").split("\n")[0]
-
-        if first_line.startswith("CONNECT"):
-            https_handler = self._create_handler(
-                HttpsHandler,
-                ssl_config=self.ssl_config,
-                cancel_inspect_queue=self.cancel_inspect_queue,
-                cancel_inspect_result_queue=self.cancel_inspect_result_queue,
-            )
-            https_handler.handle_https_connection(client_socket, first_line)
-        else:
-            http_handler = self._create_handler(HttpHandler)
-            http_handler.handle_http_request(client_socket, request)

{pyproxytools-0.4.4 → pyproxytools-0.4.6}/pyproxy/handlers/http.py

@@ -202,15 +202,24 @@ class HttpHandler:
             server_port = parsed_url.port or (
                 443 if parsed_url.scheme == "https" else 80
             )
+
+        try:
+            ip_address = socket.gethostbyname(server_host)
+        except socket.gaierror:
+            ip_address = server_host
+
         thread_id = threading.get_ident()
 
         if thread_id in self.active_connections:
-            self.active_connections[thread_id] = {
-                "target_ip": server_host,
-                "target_port": server_port,
-                "bytes_sent": 0,
-                "bytes_received": 0,
-            }
+            self.active_connections[thread_id].update(
+                {
+                    "target_ip": ip_address,
+                    "target_domain": server_host,
+                    "target_port": server_port,
+                    "bytes_sent": 0,
+                    "bytes_received": 0,
+                }
+            )
 
         try:
             server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

{pyproxytools-0.4.4 → pyproxytools-0.4.6}/pyproxy/handlers/https.py

@@ -206,6 +206,21 @@ class HttpsHandler:
             if self._is_blocked(f"{server_host}{path}"):
                 return None, full_url, True
 
+            if not self.logger_config.no_logging_access:
+                method, domain_port, protocol = first_line.split(" ")
+                domain, port = domain_port.split(":")
+                self.logger_config.access_logger.info(
+                    "",
+                    extra={
+                        "ip_src": ssl_client_socket.getpeername()[0],
+                        "url": full_url,
+                        "method": method,
+                        "domain": server_host,
+                        "port": port,
+                        "protocol": protocol,
+                    },
+                )
+
             return first_request, full_url, False
         except Exception as e:
             self.logger_config.error_logger.error(f"SSL request processing error : {e}")
@@ -231,10 +246,13 @@ class HttpsHandler:
         not_inspect = self._should_skip_inspection(server_host)
 
         thread_id = threading.get_ident()
-        self.active_connections[thread_id] = {
-            "bytes_sent": 0,
-            "bytes_received": 0,
-        }
+        self.active_connections[thread_id].update(
+            {
+                "target_domain": server_host,
+                "bytes_sent": 0,
+                "bytes_received": 0,
+            }
+        )
 
         if self.ssl_config.ssl_inspect and not not_inspect:
             try:
@@ -317,13 +335,13 @@ class HttpsHandler:
                 )
 
                 if not self.logger_config.no_logging_access:
-                    _, _, protocol = first_line.split(" ")
+                    method, _, protocol = first_line.split(" ")
                     self.logger_config.access_logger.info(
                         "",
                         extra={
                             "ip_src": client_ip,
                             "url": target,
-                            "method": "CONNECT",
+                            "method": method,
                             "domain": server_host,
                             "port": server_port,
                             "protocol": protocol,

pyproxytools-0.4.6/pyproxy/monitoring/__init__.py

@@ -0,0 +1,38 @@
+"""
+pyproxy.monitoring.__init__.py
+
+Provides a monitoring system for the ProxyServer, exposing information about
+processes, threads, active connections, and subprocesses. Implements an HTTP
+server using Flask to provide monitoring endpoints.
+"""
+
+import logging
+from flask import Flask
+from .monitor import ProxyMonitor
+from .auth import create_basic_auth
+from .routes import register_routes
+
+
+def start_flask_server(proxy_server, flask_port, flask_pass, debug) -> None:
+    """
+    Launches a Flask HTTP server to monitor the ProxyServer.
+
+    The server exposes endpoints that provide status information about
+    the proxy server, including process details, thread information,
+    subprocess statuses, and active connections.
+
+    Args:
+        proxy_server (ProxyServer): The ProxyServer instance to monitor.
+        flask_port (int): The port number on which the Flask server will listen.
+        flask_pass (str): The password used for basic HTTP authentication.
+        debug (bool): Flag to enable or disable Flask debug mode.
+    """
+    auth = create_basic_auth(flask_pass)
+
+    app = Flask(__name__, static_folder="static")
+    if not debug:
+        log = logging.getLogger("werkzeug")
+        log.setLevel(logging.ERROR)
+
+    register_routes(app, auth, proxy_server, ProxyMonitor)
+    app.run(host="0.0.0.0", port=flask_port)  # nosec

pyproxytools-0.4.6/pyproxy/monitoring/auth.py

@@ -0,0 +1,31 @@
+"""
+pyproxy.monitoring.auth.py
+
+Provides HTTP Basic Authentication setup for the monitoring Flask server,
+using a single hardcoded user 'admin' with a hashed password.
+"""
+
+from flask_httpauth import HTTPBasicAuth
+from werkzeug.security import check_password_hash, generate_password_hash
+
+
+def create_basic_auth(password: str):
+    """
+    Creates and configures an HTTPBasicAuth instance with a single user.
+
+    Args:
+        password (str): The password for the 'admin' user.
+
+    Returns:
+        HTTPBasicAuth: Configured HTTPBasicAuth instance for use in Flask.
+    """
+    auth = HTTPBasicAuth()
+    users = {"admin": generate_password_hash(password)}
+
+    @auth.verify_password
+    def verify_password(username, passwd):
+        if username in users and check_password_hash(users.get(username), passwd):
+            return username
+        return None
+
+    return auth

pyproxytools-0.4.6/pyproxy/monitoring/monitor.py

@@ -0,0 +1,196 @@
+"""
+pyproxy.monitoring.monitor
+
+This module defines the ProxyMonitor class, which provides monitoring capabilities
+for the ProxyServer. It collects and exposes real-time information about the
+main process, threads, subprocesses, and active client connections using `psutil`,
+`threading`, and `multiprocessing` libraries.
+"""
+
+import os
+import threading
+import multiprocessing
+from datetime import datetime
+from typing import List, Dict, Union
+import psutil
+
+
+class ProxyMonitor:
+    """
+    Monitors the status of the ProxyServer, including details about
+    the main process, threads, subprocesses, and active client connections.
+
+    Args:
+        proxy_server (ProxyServer): The instance of the ProxyServer to monitor.
+    """
+
+    def __init__(self, proxy_server):
+        self.proxy_server = proxy_server
+
+    def get_process_info(
+        self,
+    ) -> Dict[str, Union[int, str, List[Dict[str, Union[int, str]]]]]:
+        """
+        Retrieves overall process information for the ProxyServer,
+        including the PID, name, status, and details about threads,
+        subprocesses, and active connections.
+
+        Returns:
+            dict: A dictionary containing the process information.
+        """
+        process_info = {
+            "pid": os.getpid(),
+            "name": "ProxyServer",
+            "status": "running",
+            "start_time": datetime.fromtimestamp(
+                psutil.Process(os.getpid()).create_time()
+            ).strftime("%Y-%m-%d %H:%M:%S"),
+            "threads": self.get_threads_info(),
+            "subprocesses": self.get_subprocesses_info(),
+            "active_connections": self.get_active_connections(),
+        }
+        return process_info
+
+    def get_threads_info(self) -> List[Dict[str, Union[int, str]]]:
+        """
+        Retrieves information about the threads running in the ProxyServer.
+
+        Returns:
+            list: A list of dictionaries, each containing information
+                    about a thread.
+        """
+        threads_info = []
+        for thread in threading.enumerate():
+            threads_info.append(
+                {
+                    "thread_id": thread.ident,
+                    "name": thread.name,
+                    "status": self.get_thread_status(thread),
+                }
+            )
+        return threads_info
+
+    def get_thread_status(self, thread: threading.Thread) -> str:
+        """
+        Gets the status of a given thread.
+
+        Args:
+            thread (threading.Thread): The thread whose status is to be retrieved.
+
+        Returns:
+            str: The status of the thread ('running', 'terminated', or 'unknown').
+        """
+        try:
+            if thread.is_alive():
+                return "running"
+            return "terminated"
+        except AttributeError:
+            return "unknown"
+
+    def get_subprocesses_info(
+        self,
+    ) -> Dict[str, Dict[str, Union[str, List[Dict[str, Union[int, str]]]]]]:
+        """
+        Retrieves the status of the ProxyServer's subprocesses, including
+        filtering, shortcuts, cancel inspection, and custom header processes.
+
+        Returns:
+            dict: A dictionary containing subprocess statuses.
+        """
+        subprocesses_info = {}
+
+        subprocesses = {
+            "filter": self.proxy_server.filter_proc,
+            "shortcuts": self.proxy_server.shortcuts_proc,
+            "cancel_inspect": self.proxy_server.cancel_inspect_proc,
+            "custom_header": self.proxy_server.custom_header_proc,
+        }
+
+        for name, process in subprocesses.items():
+            if process is not None and process.is_alive():
+                subprocesses_info[name] = self.get_subprocess_status(process, name)
+        return subprocesses_info
+
+    def get_subprocess_status(
+        self, process: multiprocessing.Process, name: str
+    ) -> Dict[str, Union[str, None, List[Dict[str, Union[int, str]]]]]:
+        """
+        Retrieves the status of a subprocess.
+
+        Args:
+            process (multiprocessing.Process): The subprocess to check.
+            name (str): The name of the subprocess.
+
+        Returns:
+            dict: A dictionary containing the subprocess status.
+        """
+        if process is None:
+            return {"status": "not started", "name": name, "threads": []}
+        try:
+            status = "running" if process.is_alive() else "terminated"
+            threads_info = self.get_subprocess_threads_info(process)
+        except AttributeError:
+            status = "terminated"
+            threads_info = []
+        return {
+            "pid": process.pid if hasattr(process, "pid") else None,
+            "status": status,
+            "name": name,
+            "threads": threads_info,
+        }
+
+    def get_subprocess_threads_info(
+        self, process: multiprocessing.Process
+    ) -> List[Dict[str, Union[int, str]]]:
+        """
+        Retrieves the threads associated with a subprocess.
+
+        Args:
+            process (multiprocessing.Process): The subprocess to check.
+
+        Returns:
+            list: A list of dictionaries containing thread information.
+        """
+        threads_info = []
+        try:
+            for proc_thread in psutil.Process(process.pid).threads():
+                threads_info.append(
+                    {
+                        "thread_id": proc_thread.id,
+                        "name": f"Thread-{proc_thread.id}",
+                        "status": self.get_thread_status_by_pid(proc_thread.id),
+                    }
+                )
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+        return threads_info
+
+    def get_thread_status_by_pid(self, thread_id: int) -> str:
+        """
+        Attempts to retrieve the status of a thread by its PID.
+
+        Args:
+            thread_id (int): The thread's ID.
+
+        Returns:
+            str: The status of the thread ('running' or 'terminated').
+        """
+        try:
+            process = psutil.Process(thread_id)
+            if process.is_running():
+                return "running"
+            return "terminated"
+        except psutil.NoSuchProcess:
+            return "terminated"
+
+    def get_active_connections(self) -> List[Dict[str, Union[int, Dict]]]:
+        """
+        Retrieves information about the active client connections to the ProxyServer.
+
+        Returns:
+            list: A list of dictionaries containing information about active connections.
+        """
+        return [
+            {"thread_id": thread_id, **conn}
+            for thread_id, conn in self.proxy_server.active_connections.items()
+        ]

pyproxytools-0.4.6/pyproxy/monitoring/routes.py

@@ -0,0 +1,211 @@
+"""
+pyproxy.monitoring.routes.py
+
+Defines and registers monitoring-related routes for the Flask application,
+including endpoints for system information, configuration, and a secured
+HTML-based index page.
+"""
+
+from flask import jsonify, render_template, request
+
+
+def register_routes(app, auth, proxy_server, ProxyMonitor):
+    """
+    Registers the monitoring routes to the Flask app, secured with HTTP Basic Auth.
+
+    Args:
+        app (Flask): The Flask application instance.
+        auth (HTTPBasicAuth): The HTTP Basic Auth instance used to secure routes.
+        proxy_server (ProxyServer): The running ProxyServer instance to monitor.
+        ProxyMonitor (class): The monitoring class used to gather runtime information.
+    """
+
+    @app.route("/")
+    @auth.login_required
+    def index():
+        """
+        Serves the main index HTML page for the monitoring dashboard.
+
+        Returns:
+            Response: Rendered HTML page.
+        """
+        return render_template("index.html")
+
+    @app.route("/api/status", methods=["GET"])
+    @auth.login_required
+    def monitoring():
+        """
+        Provides real-time monitoring information about the ProxyServer,
+        including process, thread, and connection status.
+
+        Returns:
+            Response: JSON object containing monitoring data.
+        """
+        monitor = ProxyMonitor(proxy_server)
+        return jsonify(monitor.get_process_info())
+
+    @app.route("/api/settings", methods=["GET"])
+    @auth.login_required
+    def config():
+        """
+        Returns the current configuration of the ProxyServer.
+
+        The configuration includes:
+            - Host and port
+            - Debug mode
+            - 403 HTML page usage
+            - Logger configuration (if present)
+            - Filter configuration (if present)
+            - SSL configuration (if present)
+            - Flask monitoring port
+
+        Returns:
+            Response: JSON object containing configuration data.
+        """
+        config_data = {
+            "host": proxy_server.host_port[0],
+            "port": proxy_server.host_port[1],
+            "debug": proxy_server.debug,
+            "html_403": proxy_server.html_403,
+            "logger_config": (
+                proxy_server.logger_config.to_dict()
+                if proxy_server.logger_config
+                else None
+            ),
+            "filter_config": (
+                proxy_server.filter_config.to_dict()
+                if proxy_server.filter_config
+                else None
+            ),
+            "ssl_config": (
+                proxy_server.ssl_config.to_dict() if proxy_server.ssl_config else None
+            ),
+            "flask_port": proxy_server.monitoring_config.flask_port,
+        }
+        return jsonify(config_data)
+
+    @app.route("/api/filtering", methods=["GET", "POST", "DELETE"])
+    @auth.login_required
+    def blocked():
+        """
+        Manages the blocked sites and URLs list.
+
+        GET:
+            Reads and returns the current blocked domains and URLs from the corresponding files.
+            Returns:
+                Response: JSON object with 'blocked_sites' and 'blocked_url' lists.
+
+        POST:
+            Adds a new domain or URL to the blocked lists based on
+                        'type' and 'value' from JSON input.
+            Request JSON:
+                {
+                    "type": "domain" | "url",
+                    "value": "<value_to_block>"
+                }
+            Returns:
+                201: Successfully added.
+                400: Invalid input.
+                409: Value already blocked.
+
+        DELETE:
+            Removes a domain or URL from the blocked lists based on
+                        'type' and 'value' from JSON input.
+            Request JSON:
+                {
+                    "type": "domain" | "url",
+                    "value": "<value_to_unblock>"
+                }
+            Returns:
+                200: Successfully removed.
+                400: Invalid input.
+                404: Value not found.
+                500: Server error.
+        """
+        if request.method == "GET":
+            blocked_sites_content = ""
+            blocked_url_content = ""
+
+            with open(
+                proxy_server.filter_config.blocked_sites, "r", encoding="utf-8"
+            ) as f:
+                blocked_sites_content = [line.strip() for line in f if line.strip()]
+            with open(
+                proxy_server.filter_config.blocked_url, "r", encoding="utf-8"
+            ) as f:
+                blocked_url_content = [line.strip() for line in f if line.strip()]
+
+            blocked_data = {
+                "blocked_sites": blocked_sites_content,
+                "blocked_url": blocked_url_content,
+            }
+            return jsonify(blocked_data)
+
+        elif request.method == "POST":
+            data = request.get_json()
+            typ = data.get("type")
+            val = data.get("value", "").strip()
+            if not val or typ not in ["domain", "url"]:
+                return jsonify({"error": "Invalid input"}), 400
+
+            filename = (
+                proxy_server.filter_config.blocked_sites
+                if typ == "domain"
+                else proxy_server.filter_config.blocked_url
+            )
+
+            with open(filename, "r+", encoding="utf-8") as f:
+                lines = [line.strip() for line in f if line.strip()]
+                if val in lines:
+                    return jsonify({"message": "Already blocked"}), 409
+                lines.append(val)
+                f.seek(0)
+                f.truncate()
+                f.write("\n".join(lines) + "\n")
+            return jsonify({"message": "Added successfully"}), 201
+
+        elif request.method == "DELETE":
+            data = request.get_json()
+            if not data or "type" not in data or "value" not in data:
+                return (
+                    jsonify({"error": "Missing 'type' or 'value' in request body"}),
+                    400,
+                )
+
+            block_type = data["type"]
+            value = data["value"].strip()
+
+            if block_type == "domain":
+                filepath = proxy_server.filter_config.blocked_sites
+            elif block_type == "url":
+                filepath = proxy_server.filter_config.blocked_url
+            else:
+                return (
+                    jsonify({"error": "Invalid type, must be 'domain' or 'url'"}),
+                    400,
+                )
+
+            try:
+                with open(filepath, "r", encoding="utf-8") as f:
+                    lines = [line.strip() for line in f if line.strip()]
+
+                if value not in lines:
+                    return (
+                        jsonify({"error": f"{value} not found in {block_type} list"}),
+                        404,
+                    )
+
+                lines = [line for line in lines if line != value]
+
+                with open(filepath, "w", encoding="utf-8") as f:
+                    for line in lines:
+                        f.write(line + "\n")
+
+                return (
+                    jsonify(
+                        {"message": f"{block_type} '{value}' removed successfully"}
+                    ),
+                    200,
+                )
+            except Exception as e:
+                return jsonify({"error": f"Server error: {str(e)}"}), 500

{pyproxytools-0.4.4 → pyproxytools-0.4.6}/pyproxy/server.py

@@ -27,7 +27,7 @@ if not __slim__:
 if not __slim__:
     from pyproxy.modules.custom_header import custom_header_process
 if not __slim__:
-    from pyproxy.monitoring.web import start_flask_server
+    from pyproxy.monitoring import start_flask_server
 
 
 class ProxyServer:

{pyproxytools-0.4.4 → pyproxytools-0.4.6/pyproxytools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyproxytools
-Version: 0.4.4
+Version: 0.4.6
 Summary: Lightweight and fast python web proxy
 Author: pyproxytools
 License-Expression: MIT

{pyproxytools-0.4.4 → pyproxytools-0.4.6}/pyproxytools.egg-info/SOURCES.txt

@@ -21,7 +21,9 @@ pyproxy/modules/custom_header.py
 pyproxy/modules/filter.py
 pyproxy/modules/shortcuts.py
 pyproxy/monitoring/__init__.py
-pyproxy/monitoring/web.py
+pyproxy/monitoring/auth.py
+pyproxy/monitoring/monitor.py
+pyproxy/monitoring/routes.py
 pyproxy/utils/__init__.py
 pyproxy/utils/args.py
 pyproxy/utils/config.py

pyproxytools-0.4.4/pyproxy/monitoring/web.py

@@ -1,279 +0,0 @@
-"""
-pyproxy.monitoring.web.py
-
-This module defines a monitoring system for the ProxyServer that provides
-information about the server's processes, threads, active connections, and
-subprocesses. It includes an HTTP server implemented with Flask to expose
-monitoring endpoints for the proxy server.
-"""
-
-import os
-import threading
-import multiprocessing
-import logging
-from datetime import datetime
-from typing import List, Dict, Union
-from flask import Flask, jsonify, render_template
-from flask_httpauth import HTTPBasicAuth
-from werkzeug.security import check_password_hash, generate_password_hash
-import psutil
-
-
-def start_flask_server(proxy_server, flask_port, flask_pass, debug) -> None:
-    """
-    Starts the Flask server for monitoring the ProxyServer. It creates and
-    runs an HTTP server that exposes the proxy server's status, including
-    process and thread details, subprocess statuses, and active connections.
-
-    Args:
-        proxy_server (ProxyServer): The ProxyServer instance to monitor.
-
-    The server will expose two routes:
-        - '/' : Renders a simple index page.
-        - '/monitoring' : Returns a JSON response with the monitoring data.
-    """
-
-    class ProxyMonitor:
-        """
-        Monitors the status of the ProxyServer, including process, thread,
-        and subprocess information, as well as active client connections.
-
-        Args:
-            proxy_server (ProxyServer): The ProxyServer instance to monitor.
-        """
-
-        def __init__(self, proxy_server):
-            self.proxy_server = proxy_server
-
-        def get_process_info(
-            self,
-        ) -> Dict[str, Union[int, str, List[Dict[str, Union[int, str]]]]]:
-            """
-            Retrieves overall process information for the ProxyServer,
-            including the PID, name, status, and details about threads,
-            subprocesses, and active connections.
-
-            Returns:
-                dict: A dictionary containing the process information.
-            """
-            process_info = {
-                "pid": os.getpid(),
-                "name": "ProxyServer",
-                "status": "running",
-                "start_time": datetime.fromtimestamp(
-                    psutil.Process(os.getpid()).create_time()
-                ).strftime("%Y-%m-%d %H:%M:%S"),
-                "threads": self.get_threads_info(),
-                "subprocesses": self.get_subprocesses_info(),
-                "active_connections": self.get_active_connections(),
-            }
-            return process_info
-
-        def get_threads_info(self) -> List[Dict[str, Union[int, str]]]:
-            """
-            Retrieves information about the threads running in the ProxyServer.
-
-            Returns:
-                list: A list of dictionaries, each containing information
-                      about a thread.
-            """
-            threads_info = []
-            for thread in threading.enumerate():
-                threads_info.append(
-                    {
-                        "thread_id": thread.ident,
-                        "name": thread.name,
-                        "status": self.get_thread_status(thread),
-                    }
-                )
-            return threads_info
-
-        def get_thread_status(self, thread: threading.Thread) -> str:
-            """
-            Gets the status of a given thread.
-
-            Args:
-                thread (threading.Thread): The thread whose status is to be retrieved.
-
-            Returns:
-                str: The status of the thread ('running', 'terminated', or 'unknown').
-            """
-            try:
-                if thread.is_alive():
-                    return "running"
-                return "terminated"
-            except AttributeError:
-                return "unknown"
-
-        def get_subprocesses_info(
-            self,
-        ) -> Dict[str, Dict[str, Union[str, List[Dict[str, Union[int, str]]]]]]:
-            """
-            Retrieves the status of the ProxyServer's subprocesses, including
-            filtering, shortcuts, cancel inspection, and custom header processes.
-
-            Returns:
-                dict: A dictionary containing subprocess statuses.
-            """
-            subprocesses_info = {}
-
-            subprocesses = {
-                "filter": self.proxy_server.filter_proc,
-                "shortcuts": self.proxy_server.shortcuts_proc,
-                "cancel_inspect": self.proxy_server.cancel_inspect_proc,
-                "custom_header": self.proxy_server.custom_header_proc,
-            }
-
-            for name, process in subprocesses.items():
-                if process is not None and process.is_alive():
-                    subprocesses_info[name] = self.get_subprocess_status(process, name)
-            return subprocesses_info
-
-        def get_subprocess_status(
-            self, process: multiprocessing.Process, name: str
-        ) -> Dict[str, Union[str, None, List[Dict[str, Union[int, str]]]]]:
-            """
-            Retrieves the status of a subprocess.
-
-            Args:
-                process (multiprocessing.Process): The subprocess to check.
-                name (str): The name of the subprocess.
-
-            Returns:
-                dict: A dictionary containing the subprocess status.
-            """
-            if process is None:
-                return {"status": "not started", "name": name, "threads": []}
-            try:
-                status = "running" if process.is_alive() else "terminated"
-                threads_info = self.get_subprocess_threads_info(process)
-            except AttributeError:
-                status = "terminated"
-                threads_info = []
-            return {
-                "pid": process.pid if hasattr(process, "pid") else None,
-                "status": status,
-                "name": name,
-                "threads": threads_info,
-            }
-
-        def get_subprocess_threads_info(
-            self, process: multiprocessing.Process
-        ) -> List[Dict[str, Union[int, str]]]:
-            """
-            Retrieves the threads associated with a subprocess.
-
-            Args:
-                process (multiprocessing.Process): The subprocess to check.
-
-            Returns:
-                list: A list of dictionaries containing thread information.
-            """
-            threads_info = []
-            try:
-                for proc_thread in psutil.Process(process.pid).threads():
-                    threads_info.append(
-                        {
-                            "thread_id": proc_thread.id,
-                            "name": f"Thread-{proc_thread.id}",
-                            "status": self.get_thread_status_by_pid(proc_thread.id),
-                        }
-                    )
-            except (psutil.NoSuchProcess, psutil.AccessDenied):
-                pass
-            return threads_info
-
-        def get_thread_status_by_pid(self, thread_id: int) -> str:
-            """
-            Attempts to retrieve the status of a thread by its PID.
-
-            Args:
-                thread_id (int): The thread's ID.
-
-            Returns:
-                str: The status of the thread ('running' or 'terminated').
-            """
-            try:
-                process = psutil.Process(thread_id)
-                if process.is_running():
-                    return "running"
-                return "terminated"
-            except psutil.NoSuchProcess:
-                return "terminated"
-
-        def get_active_connections(self) -> List[Dict[str, Union[int, Dict]]]:
-            """
-            Retrieves information about the active client connections to the ProxyServer.
-
-            Returns:
-                list: A list of dictionaries containing information about active connections.
-            """
-            return [
-                {"thread_id": thread_id, **conn}
-                for thread_id, conn in self.proxy_server.active_connections.items()
-            ]
-
-    auth = HTTPBasicAuth()
-
-    users = {"admin": generate_password_hash(flask_pass)}
-
-    @auth.verify_password
-    def verify_password(username, password):
-        if username in users and check_password_hash(users.get(username), password):
-            return username
-        return None
-
-    app = Flask(__name__, static_folder="static")
-    if not debug:
-        log = logging.getLogger("werkzeug")
-        log.setLevel(logging.ERROR)
-
-    @app.route("/")
-    @auth.login_required
-    def index():
-        """
-        Renders the index page for the Flask application.
-
-        Returns:
-            str: The rendered HTML content of the index page.
-        """
-        return render_template("index.html")
-
-    @app.route("/monitoring", methods=["GET"])
-    @auth.login_required
-    def monitoring():
-        """
-        Returns the monitoring data for the ProxyServer in JSON format.
-
-        Returns:
-            Response: A JSON response containing the server's process information.
-        """
-        monitor = ProxyMonitor(proxy_server)
-        return jsonify(monitor.get_process_info())
-
-    @app.route("/config", methods=["GET"])
-    @auth.login_required
-    def config():
-        config_data = {
-            "host": proxy_server.host_port[0],
-            "port": proxy_server.host_port[1],
-            "debug": proxy_server.debug,
-            "html_403": proxy_server.html_403,
-            "logger_config": (
-                proxy_server.logger_config.to_dict()
-                if proxy_server.logger_config
-                else None
-            ),
-            "filter_config": (
-                proxy_server.filter_config.to_dict()
-                if proxy_server.filter_config
-                else None
-            ),
-            "ssl_config": (
-                proxy_server.ssl_config.to_dict() if proxy_server.ssl_config else None
-            ),
-            "flask_port": proxy_server.monitoring_config.flask_port,
-        }
-        return jsonify(config_data)
-
-    app.run(host="0.0.0.0", port=flask_port)  # nosec