Deploy Gradio app with multiple files

app.py

@@ -0,0 +1,244 @@
+import gradio as gr
+import threading
+import socket
+import time
+import json
+import requests
+from datetime import datetime
+from typing import Dict, List, Optional
+import logging
+from utils import SOCKS5ProxyServer, ProxyManager
+from config import *
+
+# สร้างตัวจัดการ proxy
+proxy_manager = ProxyManager()
+
+def start_proxy_server():
+    """เริ่มต้น proxy server"""
+    success = proxy_manager.start_server()
+    if success:
+        return "✅ เริ่มต้น Proxy Server สำเร็จ"
+    else:
+        return "❌ ไม่สามารถเริ่มต้น Proxy Server ได้"
+
+def stop_proxy_server():
+    """หยุด proxy server"""
+    proxy_manager.stop_server()
+    return "🛑 หยุด Proxy Server แล้ว"
+
+def restart_proxy_server():
+    """รีสตาร์ท proxy server"""
+    proxy_manager.stop_server()
+    time.sleep(1)
+    success = proxy_manager.start_server()
+    if success:
+        return "🔄 รีสตาร์ท Proxy Server สำเร็จ"
+    else:
+        return "❌ ไม่สามารถรีสตาร์ท Proxy Server ได้"
+
+def get_current_proxy_url():
+    """ดึง URL proxy ปัจจุบัน"""
+    if proxy_manager.is_running():
+        return f"socks5://localhost:{PROXY_PORT}"
+    return "ไม่ได้เชื่อมต่อ"
+
+def get_server_info():
+    """ดึงข้อมูล server"""
+    return json.dumps(proxy_manager.get_server_info(), indent=2, ensure_ascii=False)
+
+def get_usage_stats():
+    """ดึงสถิติการใช้งาน"""
+    return json.dumps(proxy_manager.get_usage_stats(), indent=2, ensure_ascii=False)
+
+def get_user_stats():
+    """ดึงข้อมูลผู้ใช้"""
+    return json.dumps(proxy_manager.get_user_stats(), indent=2, ensure_ascii=False)
+
+def get_connection_logs():
+    """ดึง log การเชื่อมต่อ"""
+    return json.dumps(proxy_manager.get_recent_logs(), indent=2, ensure_ascii=False)
+
+def refresh_all():
+    """รีเฟรชข้อมูลทั้งหมด"""
+    return (
+        get_current_proxy_url(),
+        get_server_info(),
+        get_usage_stats(),
+        get_user_stats(),
+        get_connection_logs()
+    )
+
+def setup_interface():
+    """สร้าง Gradio interface"""
+    
+    # Custom CSS สำหรับ styling
+    css = """
+    .main-container {
+        max-width: 1200px;
+        margin: auto;
+        padding: 20px;
+    }
+    .status-indicator {
+        padding: 10px;
+        border-radius: 5px;
+        margin: 5px 0;
+    }
+    .status-running {
+        background-color: #d4edda;
+        color: #155724;
+        border: 1px solid #c3e6cb;
+    }
+    .status-stopped {
+        background-color: #f8d7da;
+        color: #721c24;
+        border: 1px solid #f5c6cb;
+    }
+    .info-box {
+        background-color: #e9ecef;
+        padding: 15px;
+        border-radius: 5px;
+        margin: 10px 0;
+        border-left: 4px solid #007bff;
+    }
+    .stats-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+        gap: 15px;
+        margin: 20px 0;
+    }
+    .stat-card {
+        background: white;
+        padding: 15px;
+        border-radius: 8px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        border: 1px solid #dee2e6;
+    }
+    .stat-number {
+        font-size: 24px;
+        font-weight: bold;
+        color: #007bff;
+    }
+    .stat-label {
+        color: #6c757d;
+        font-size: 14px;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="SOCKS5 Proxy Dashboard") as demo:
+        gr.HTML("""
+        <div class="main-container">
+            <div style="text-align: center; margin-bottom: 30px;">
+                <h1>🔒 SOCKS5 Proxy Server Dashboard</h1>
+                <p style="color: #6c757d;">ระบบจัดการ SOCKS5 Proxy Server พร้อมการติดตามการใช้งาน</p>
+                <div style="margin-top: 10px;">
+                    <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank" style="text-decoration: none; color: #007bff; font-weight: bold;">Built with anycoder</a>
+                </div>
+            </div>
+        </div>
+        """)
+        
+        # สถานะปัจจุบัน
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML('<h3>🎮 การควบคุม</h3>')
+                with gr.Row():
+                    start_btn = gr.Button("▶️ เริ่มต้น", variant="primary", size="lg")
+                    stop_btn = gr.Button("⏹️ หยุด", variant="stop", size="lg")
+                    restart_btn = gr.Button("🔄 รีสตาร์ท", variant="secondary", size="lg")
+                
+                status_html = gr.HTML()
+                proxy_url_output = gr.Textbox(
+                    label="🌐 Proxy URL ปัจจุบัน",
+                    value=get_current_proxy_url,
+                    interactive=False,
+                    elem_classes=["info-box"]
+                )
+                
+            with gr.Column(scale=2):
+                gr.HTML('<h3>📊 สถิติการใช้งาน</h3>')
+                with gr.Row():
+                    total_connections = gr.Number(label="📈 การเชื่อมต่อทั้งหมด", value=0)
+                    active_connections = gr.Number(label="🔗 การเชื่อมต่อที่กำลังใช้งาน", value=0)
+                    bandwidth_used = gr.Number(label="📊 Bandwidth ใช้งาน (MB)", value=0)
+                
+                uptime_output = gr.Textbox(
+                    label="⏱️ เวลาทำงาน",
+                    interactive=False,
+                    value="00:00:00"
+                )
+        
+        # ข้อมูลผู้ใช้
+        with gr.Tab("👥 ผู้ใช้งาน"):
+            user_stats = gr.JSON(
+                label="ข้อมูลผู้ใช้ทั้งหมด",
+                value=get_user_stats
+            )
+        
+        # ข้อมูล Server
+        with gr.Tab("🖥️ ข้อมูล Server"):
+            server_info = gr.JSON(
+                label="ข้อมูล Server",
+                value=get_server_info
+            )
+        
+        # สถิติการใช้งาน
+        with gr.Tab("📊 สถิติ"):
+            usage_stats = gr.JSON(
+                label="สถิติการใช้งาน",
+                value=get_usage_stats
+            )
+        
+        # ล็อก
+        with gr.Tab("📝 ล็อก"):
+            logs = gr.JSON(
+                label="ล็อกการเชื่อมต่อล่าสุด",
+                value=get_connection_logs
+            )
+        
+        # ปุ่มรีเฟรช
+        with gr.Row():
+            refresh_btn = gr.Button("🔄 รีเฟรชข้อมูลทั้งหมด", variant="primary")
+        
+        # ผูก events
+        start_btn.click(start_proxy_server, outputs=proxy_url_output)
+        stop_btn.click(stop_proxy_server, outputs=proxy_url_output)
+        restart_btn.click(restart_proxy_server, outputs=proxy_url_output)
+        refresh_btn.click(
+            refresh_all,
+            outputs=[
+                proxy_url_output,
+                server_info,
+                usage_stats,
+                user_stats,
+                logs
+            ]
+        )
+        
+        # อัปเดตข้อมูลอัตโนมัติ
+        demo.load(
+            refresh_all,
+            outputs=[
+                proxy_url_output,
+                server_info,
+                usage_stats,
+                user_stats,
+                logs
+            ]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    # สร้าง interface
+    demo = setup_interface()
+    
+    # เริ่มต้น proxy server อัตโนมัติ
+    proxy_manager.start_server()
+    
+    # เริ่ม UI
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=8080,
+        show_api=False,
+        title="SOCKS5 Proxy Dashboard"
+    )

config.py

@@ -0,0 +1,16 @@
+# การตั้งค่า SOCKS5 Proxy Server
+PROXY_HOST = "0.0.0.0"
+PROXY_PORT = 1080
+
+# การตั้งค่า Web Interface
+WEB_HOST = "0.0.0.0"
+WEB_PORT = 8080
+
+# การตั้งค่า Logging
+LOG_LEVEL = "INFO"
+LOG_FILE = "proxy.log"
+
+# การตั้งค่าอื่นๆ
+MAX_CONNECTIONS = 100
+CONNECTION_TIMEOUT = 300  # วินาที
+BUFFER_SIZE = 4096  # bytes

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+requests

utils.py

@@ -0,0 +1,352 @@
+import socket
+import threading
+import time
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+import struct
+
+@dataclass
+class ConnectionInfo:
+    ip: str
+    port: int
+    start_time: datetime
+    bytes_sent: int = 0
+    bytes_received: int = 0
+    is_active: bool = True
+
+class SOCKS5ProxyServer:
+    def __init__(self, host='0.0.0.0', port=1080):
+        self.host = host
+        self.port = port
+        self.server_socket = None
+        self.running = False
+        self.connections: Dict[str, ConnectionInfo] = {}
+        self.total_connections = 0
+        self.start_time = None
+        self._lock = threading.Lock()
+        
+    def start(self):
+        """เริ่มต้น SOCKS5 proxy server"""
+        try:
+            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            self.server_socket.bind((self.host, self.port))
+            self.server_socket.listen(50)
+            self.running = True
+            self.start_time = datetime.now()
+            
+            logging.info(f"SOCKS5 Proxy Server เริ่มต้นที่ {self.host}:{self.port}")
+            
+            # เริ่ม thread สำหรับ accept connections
+            threading.Thread(target=self._accept_connections, daemon=True).start()
+            
+            return True
+        except Exception as e:
+            logging.error(f"เริ่มต้น proxy server ผิดพลาด: {e}")
+            return False
+    
+    def stop(self):
+        """หยุด SOCKS5 proxy server"""
+        self.running = False
+        if self.server_socket:
+            try:
+                self.server_socket.close()
+            except:
+                pass
+        logging.info("SOCKS5 Proxy Server หยุดทำงาน")
+    
+    def _accept_connections(self):
+        """รับการเชื่อมต่อใหม่"""
+        while self.running:
+            try:
+                client_socket, client_address = self.server_socket.accept()
+                client_ip, client_port = client_address
+                
+                # บันทึกการเชื่อมต่อ
+                with self._lock:
+                    self.connections[f"{client_ip}:{client_port}"] = ConnectionInfo(
+                        ip=client_ip,
+                        port=client_port,
+                        start_time=datetime.now()
+                    )
+                    self.total_connections += 1
+                
+                # สร้าง thread สำหรับจัดการการเชื่อมต่อ
+                threading.Thread(
+                    target=self._handle_client,
+                    args=(client_socket, client_ip, client_port),
+                    daemon=True
+                ).start()
+                
+            except socket.error:
+                if self.running:
+                    logging.error("Error ในการรับการเชื่อมต่อ")
+                break
+    
+    def _handle_client(self, client_socket, client_ip, client_port):
+        """จัดการการเชื่อมต่อจาก client"""
+        try:
+            # SOCKS5 handshake
+            if not self._handle_socks5_handshake(client_socket):
+                return
+            
+            # รับคำขอจาก client
+            request = client_socket.recv(1024)
+            if len(request) < 10:
+                return
+            
+            # แยกคำขอ SOCKS5
+            if request[0] != 0x05:  # Version 5
+                return
+            
+            cmd = request[1]  # Command
+            addr_type = request[3]  # Address type
+            
+            if cmd == 0x01:  # CONNECT
+                self._handle_connect(client_socket, request, client_ip, client_port)
+            elif cmd == 0x02:  # BIND
+                self._handle_bind(client_socket, client_ip, client_port)
+            elif cmd == 0x03:  # UDP ASSOCIATE
+                self._handle_udp_associate(client_socket, client_ip, client_port)
+                
+        except Exception as e:
+            logging.error(f"Error ในการจัดการ client {client_ip}:{client_port}: {e}")
+        finally:
+            # ปิดการเชื่อมต่อ
+            try:
+                client_socket.close()
+            except:
+                pass
+            
+            # อัปเดตสถานะ
+            with self._lock:
+                if f"{client_ip}:{client_port}" in self.connections:
+                    self.connections[f"{client_ip}:{client_port}"].is_active = False
+    
+    def _handle_socks5_handshake(self, client_socket):
+        """จัดการ SOCKS5 handshake"""
+        try:
+            # ��ับ client hello
+            data = client_socket.recv(1024)
+            if len(data) < 2:
+                return False
+            
+            version = data[0]
+            nmethods = data[1]
+            
+            if version != 0x05:  # Version 5
+                return False
+            
+            # ตอบกลับว่าใช้ no authentication
+            response = b'\x05\x00'
+            client_socket.send(response)
+            return True
+            
+        except Exception as e:
+            logging.error(f"Handshake error: {e}")
+            return False
+    
+    def _handle_connect(self, client_socket, request, client_ip, client_port):
+        """จัดการ SOCKS5 CONNECT command"""
+        try:
+            addr_type = request[3]
+            dest_addr = ""
+            dest_port = 0
+            
+            if addr_type == 0x01:  # IPv4
+                dest_ip = socket.inet_ntoa(request[4:8])
+                dest_port = struct.unpack('!H', request[8:10])[0]
+                dest_addr = dest_ip
+            elif addr_type == 0x03:  # Domain name
+                domain_length = request[4]
+                dest_addr = request[5:5+domain_length].decode('utf-8')
+                dest_port = struct.unpack('!H', request[5+domain_length:7+domain_length])[0]
+            elif addr_type == 0x04:  # IPv6
+                dest_ip = socket.inet_ntop(socket.AF_INET6, request[4:20])
+                dest_port = struct.unpack('!H', request[20:22])[0]
+                dest_addr = dest_ip
+            
+            # เชื่อมต่อไปยังเป้าหมาย
+            target_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            target_socket.connect((dest_addr, dest_port))
+            
+            # ตอบกลับว่าสำเร็จ
+            reply = b'\x05\x00\x00\x01' + socket.inet_aton('0.0.0.0') + b'\x00\x00'
+            client_socket.send(reply)
+            
+            # เริ่มตัวกลางข้อมูล
+            threading.Thread(
+                target=self._relay_data,
+                args=(client_socket, target_socket, client_ip, client_port),
+                daemon=True
+            ).start()
+            
+            logging.info(f"CONNECT: {client_ip}:{client_port} -> {dest_addr}:{dest_port}")
+            
+        except Exception as e:
+            # ส่ง error response
+            reply = b'\x05\x05\x00\x01\x00\x00\x00\x00\x00\x00'
+            try:
+                client_socket.send(reply)
+            except:
+                pass
+            logging.error(f"CONNECT error: {e}")
+    
+    def _handle_bind(self, client_socket, client_ip, client_port):
+        """จัดการ SOCKS5 BIND command"""
+        # BIND command implementation (สำหรับ incoming connections)
+        reply = b'\x05\x07\x00\x01\x00\x00\x00\x00\x00\x00'  # Command not supported
+        try:
+            client_socket.send(reply)
+        except:
+            pass
+    
+    def _handle_udp_associate(self, client_socket, client_ip, client_port):
+        """จัดการ SOCKS5 UDP ASSOCIATE command"""
+        # UDP ASSOCIATE implementation
+        reply = b'\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00'
+        try:
+            client_socket.send(reply)
+        except:
+            pass
+    
+    def _relay_data(self, client_socket, target_socket, client_ip, client_port):
+        """ส่งข้อมูลระหว่าง client และ target"""
+        try:
+            while True:
+                try:
+                    data = client_socket.recv(4096)
+                    if not data:
+                        break
+                    
+                    # ส่งต่อไปยัง target
+                    target_socket.send(data)
+                    
+                    # อัปเดตสถิติ
+                    with self._lock:
+                        if f"{client_ip}:{client_port}" in self.connections:
+                            conn = self.connections[f"{client_ip}:{client_port}"]
+                            conn.bytes_sent += len(data)
+                    
+                except socket.error:
+                    break
+                
+                try:
+                    data = target_socket.recv(4096)
+                    if not data:
+                        break
+                    
+                    # ส่งต่อกลับไปยัง client
+                    client_socket.send(data)
+                    
+                    # อัปเดตสถิติ
+                    with self._lock:
+                        if f"{client_ip}:{client_port}" in self.connections:
+                            conn = self.connections[f"{client_ip}:{client_port}"]
+                            conn.bytes_received += len(data)
+                    
+                except socket.error:
+                    break
+                    
+        except Exception as e:
+            logging.error(f"Relay error: {e}")
+        finally:
+            try:
+                client_socket.close()
+                target_socket.close()
+            except:
+                pass
+
+class ProxyManager:
+    def __init__(self, host='0.0.0.0', port=1080):
+        self.proxy_server = SOCKS5ProxyServer(host, port)
+        self.host = host
+        self.port = port
+        
+    def start_server(self):
+        """เริ่มต้น proxy server"""
+        return self.proxy_server.start()
+    
+    def stop_server(self):
+        """หยุด proxy server"""
+        self.proxy_server.stop()
+    
+    def is_running(self):
+        """ตรวจสอบว่า server กำลังทำงานอยู่หรือไม่"""
+        return self.proxy_server.running
+    
+    def get_server_info(self):
+        """ดึงข้อมูล server"""
+        info = {
+            "server_status": "รันอยู่" if self.proxy_server.running else "หยุดทำงาน",
+            "host": self.proxy_server.host,
+            "port": self.proxy_server.port,
+            "version": "SOCKS5",
+            "authentication": "ไม่ต้องยืนยันตัวตน",
+            "start_time": self.proxy_server.start_time.isoformat() if self.proxy_server.start_time else None,
+            "uptime": str(datetime.now() - self.proxy_server.start_time) if self.proxy_server.start_time else "00:00:00"
+        }
+        return info
+    
+    def get_usage_stats(self):
+        """ดึงสถิติการใช้งาน"""
+        total_connections = len([c for c in self.proxy_server.connections.values() if not c.is_active])
+        active_connections = len([c for c in self.proxy_server.connections.values() if c.is_active])
+        
+        total_bytes = sum(c.bytes_sent + c.bytes_received for c in self.proxy_server.connections.values())
+        
+        stats = {
+            "total_connections": total_connections,
+            "active_connections": active_connections,
+            "total_bandwidth_bytes": total_bytes,
+            "total_bandwidth_mb": round(total_bytes / (1024 * 1024), 2),
+            "peak_concurrent": max(active_connections, 0),
+            "average_session_duration": "ไม่มีข้อมูล"
+        }
+        
+        return stats
+    
+    def get_user_stats(self):
+        """ดึงข้อมูลผู้ใช้"""
+        users = []
+        for conn_id, conn in self.proxy_server.connections.items():
+            users.append({
+                "id": conn_id,
+                "ip": conn.ip,
+                "port": conn.port,
+                "connected_since": conn.start_time.isoformat(),
+                "is_active": conn.is_active,
+                "bytes_sent": conn.bytes_sent,
+                "bytes_received": conn.bytes_received,
+                "total_bytes": conn.bytes_sent + conn.bytes_received,
+                "session_duration": str(datetime.now() - conn.start_time)
+            })
+        
+        return {
+            "total_users": len(users),
+            "active_users": len([u for u in users if u["is_active"]]),
+            "users": users
+        }
+    
+    def get_recent_logs(self):
+        """ดึงล็อกการเชื่อมต่อล่าสุด"""
+        logs = []
+        for conn_id, conn in self.proxy_server.connections.items():
+            logs.append({
+                "timestamp": conn.start_time.isoformat(),
+                "client": f"{conn.ip}:{conn.port}",
+                "status": "เชื่อมต่ออยู่" if conn.is_active else "เสร็จสิ้น",
+                "bytes_transferred": conn.bytes_sent + conn.bytes_received,
+                "session_duration": str(datetime.now() - conn.start_time)
+            })
+        
+        # เรียงตามเวลาใหม่สุดก่อน
+        logs.sort(key=lambda x: x["timestamp"], reverse=True)
+        
+        return {
+            "recent_connections": logs[:50],  # แสดง 50 รายการล่าสุด
+            "total_log_entries": len(logs)
+        }