""" TTS Server Manager - Giao diện quản lý server với điều chỉnh thông số real-time """ import tkinter as tk from tkinter import ttk, messagebox import requests import threading import time import json from datetime import datetime import subprocess import os import signal class ServerManager: def __init__(self, root): self.root = root self.root.title("VieNeu-TTS Server Manager") self.root.geometry("800x600") # Server config self.server_url = "http://127.0.0.1:8000" self.server_process = None # Current settings self.current_settings = { "gpu_semaphore": 2, "cpu_semaphore": 4, "io_semaphore": 6, "thread_pool": 6 } self.setup_ui() self.start_monitoring() def setup_ui(self): # Main notebook notebook = ttk.Notebook(self.root) notebook.pack(fill=tk.BOTH, expand=True, padx=10, pady=10) # Server Control Tab self.setup_server_tab(notebook) # Settings Tab self.setup_settings_tab(notebook) # Monitor Tab self.setup_monitor_tab(notebook) def setup_server_tab(self, notebook): """Tab điều khiển server""" server_frame = ttk.Frame(notebook) notebook.add(server_frame, text="Server Control") # Server status status_frame = ttk.LabelFrame(server_frame, text="Server Status", padding="10") status_frame.pack(fill=tk.X, pady=(0, 10)) self.status_label = ttk.Label(status_frame, text="Checking server...", font=("Arial", 12)) self.status_label.pack() # Server controls control_frame = ttk.LabelFrame(server_frame, text="Server Controls", padding="10") control_frame.pack(fill=tk.X, pady=(0, 10)) button_frame = ttk.Frame(control_frame) button_frame.pack() self.start_btn = ttk.Button(button_frame, text="Start Server", command=self.start_server) self.start_btn.pack(side=tk.LEFT, padx=(0, 10)) self.stop_btn = ttk.Button(button_frame, text="Stop Server", command=self.stop_server, state="disabled") self.stop_btn.pack(side=tk.LEFT, padx=(0, 10)) self.restart_btn = ttk.Button(button_frame, text="Restart Server", command=self.restart_server) self.restart_btn.pack(side=tk.LEFT) # Quick actions quick_frame = ttk.LabelFrame(server_frame, text="Quick Actions", padding="10") quick_frame.pack(fill=tk.X, pady=(0, 10)) ttk.Button(quick_frame, text="Open API Docs", command=self.open_api_docs).pack(side=tk.LEFT, padx=(0, 10)) ttk.Button(quick_frame, text="Test Server", command=self.test_server).pack(side=tk.LEFT, padx=(0, 10)) ttk.Button(quick_frame, text="Clear Cache", command=self.clear_cache).pack(side=tk.LEFT) def setup_settings_tab(self, notebook): """Tab cài đặt async parameters""" settings_frame = ttk.Frame(notebook) notebook.add(settings_frame, text="Async Settings") # Current settings display current_frame = ttk.LabelFrame(settings_frame, text="Current Settings", padding="10") current_frame.pack(fill=tk.X, pady=(0, 10)) self.current_settings_text = tk.Text(current_frame, height=4, width=60, state="disabled") self.current_settings_text.pack() # Settings controls control_frame = ttk.LabelFrame(settings_frame, text="Adjust Settings", padding="10") control_frame.pack(fill=tk.X, pady=(0, 10)) # GPU Semaphore gpu_frame = ttk.Frame(control_frame) gpu_frame.pack(fill=tk.X, pady=(0, 5)) ttk.Label(gpu_frame, text="GPU Semaphore (1-4):").pack(side=tk.LEFT) self.gpu_var = tk.StringVar(value="2") gpu_spin = ttk.Spinbox(gpu_frame, from_=1, to=4, width=10, textvariable=self.gpu_var) gpu_spin.pack(side=tk.RIGHT) # CPU Semaphore cpu_frame = ttk.Frame(control_frame) cpu_frame.pack(fill=tk.X, pady=(0, 5)) ttk.Label(cpu_frame, text="CPU Semaphore (2-8):").pack(side=tk.LEFT) self.cpu_var = tk.StringVar(value="4") cpu_spin = ttk.Spinbox(cpu_frame, from_=2, to=8, width=10, textvariable=self.cpu_var) cpu_spin.pack(side=tk.RIGHT) # I/O Semaphore io_frame = ttk.Frame(control_frame) io_frame.pack(fill=tk.X, pady=(0, 5)) ttk.Label(io_frame, text="I/O Semaphore (3-10):").pack(side=tk.LEFT) self.io_var = tk.StringVar(value="6") io_spin = ttk.Spinbox(io_frame, from_=3, to=10, width=10, textvariable=self.io_var) io_spin.pack(side=tk.RIGHT) # Thread Pool thread_frame = ttk.Frame(control_frame) thread_frame.pack(fill=tk.X, pady=(0, 10)) ttk.Label(thread_frame, text="Thread Pool (2-12):").pack(side=tk.LEFT) self.thread_var = tk.StringVar(value="6") thread_spin = ttk.Spinbox(thread_frame, from_=2, to=12, width=10, textvariable=self.thread_var) thread_spin.pack(side=tk.RIGHT) # Apply buttons apply_frame = ttk.Frame(control_frame) apply_frame.pack(fill=tk.X) ttk.Button(apply_frame, text="Apply Settings", command=self.apply_settings).pack(side=tk.LEFT, padx=(0, 10)) ttk.Button(apply_frame, text="Reset to Default", command=self.reset_settings).pack(side=tk.LEFT, padx=(0, 10)) ttk.Button(apply_frame, text="Load Presets", command=self.show_presets).pack(side=tk.LEFT) # Presets presets_frame = ttk.LabelFrame(settings_frame, text="Performance Presets", padding="10") presets_frame.pack(fill=tk.X) preset_buttons = ttk.Frame(presets_frame) preset_buttons.pack() ttk.Button(preset_buttons, text="Light (1,2,3,3)", command=lambda: self.apply_preset(1,2,3,3)).pack(side=tk.LEFT, padx=(0, 5)) ttk.Button(preset_buttons, text="Balanced (2,4,6,6)", command=lambda: self.apply_preset(2,4,6,6)).pack(side=tk.LEFT, padx=(0, 5)) ttk.Button(preset_buttons, text="Performance (3,6,8,8)", command=lambda: self.apply_preset(3,6,8,8)).pack(side=tk.LEFT, padx=(0, 5)) ttk.Button(preset_buttons, text="Max (4,8,10,12)", command=lambda: self.apply_preset(4,8,10,12)).pack(side=tk.LEFT) def setup_monitor_tab(self, notebook): """Tab monitor server""" monitor_frame = ttk.Frame(notebook) notebook.add(monitor_frame, text="Monitor") # Resource usage resource_frame = ttk.LabelFrame(monitor_frame, text="Resource Usage", padding="10") resource_frame.pack(fill=tk.X, pady=(0, 10)) self.resource_text = tk.Text(resource_frame, height=8, width=70, state="disabled") self.resource_text.pack() # Recent requests requests_frame = ttk.LabelFrame(monitor_frame, text="Recent Activity", padding="10") requests_frame.pack(fill=tk.BOTH, expand=True) self.activity_text = tk.Text(requests_frame, height=15, width=70, state="disabled") scrollbar = ttk.Scrollbar(requests_frame, orient="vertical", command=self.activity_text.yview) self.activity_text.configure(yscrollcommand=scrollbar.set) self.activity_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) scrollbar.pack(side=tk.RIGHT, fill=tk.Y) # Auto refresh refresh_frame = ttk.Frame(monitor_frame) refresh_frame.pack(fill=tk.X, pady=(10, 0)) self.auto_refresh_var = tk.BooleanVar(value=True) ttk.Checkbutton(refresh_frame, text="Auto Refresh", variable=self.auto_refresh_var).pack(side=tk.LEFT) ttk.Button(refresh_frame, text="Refresh Now", command=self.refresh_monitor).pack(side=tk.RIGHT) def start_server(self): """Start TTS server""" try: if self.server_process and self.server_process.poll() is None: messagebox.showwarning("Warning", "Server is already running!") return self.log_activity("Starting TTS server...") # Start server process self.server_process = subprocess.Popen( ["python", "tts_server.py"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, universal_newlines=True ) self.start_btn.config(state="disabled") self.stop_btn.config(state="normal") # Monitor server output threading.Thread(target=self.monitor_server_output, daemon=True).start() self.log_activity("Server starting... Please wait for initialization.") except Exception as e: messagebox.showerror("Error", f"Failed to start server: {str(e)}") def stop_server(self): """Stop TTS server""" try: if self.server_process: self.log_activity("Stopping TTS server...") self.server_process.terminate() self.server_process.wait(timeout=10) self.server_process = None self.start_btn.config(state="normal") self.stop_btn.config(state="disabled") self.log_activity("Server stopped.") except Exception as e: messagebox.showerror("Error", f"Failed to stop server: {str(e)}") def restart_server(self): """Restart server""" self.stop_server() time.sleep(2) self.start_server() def monitor_server_output(self): """Monitor server console output""" if not self.server_process: return try: for line in iter(self.server_process.stdout.readline, ''): if line: # Only log important messages, not all console output if any(keyword in line for keyword in ['✅', '❌', '🎤', '📊', 'ERROR', 'WARNING']): self.log_activity(f"Server: {line.strip()}") if self.server_process.poll() is not None: break except Exception as e: self.log_activity(f"Error monitoring server: {str(e)}") def apply_settings(self): """Apply new async settings""" try: new_settings = { "gpu_semaphore": int(self.gpu_var.get()), "cpu_semaphore": int(self.cpu_var.get()), "io_semaphore": int(self.io_var.get()), "thread_pool": int(self.thread_var.get()) } # Send settings to server via API response = requests.post(f"{self.server_url}/admin/update_settings", json=new_settings, timeout=5) if response.status_code == 200: self.current_settings = new_settings self.update_current_settings_display() self.log_activity(f"Settings applied: GPU({new_settings['gpu_semaphore']}) CPU({new_settings['cpu_semaphore']}) I/O({new_settings['io_semaphore']}) Threads({new_settings['thread_pool']})") messagebox.showinfo("Success", "Settings applied successfully!") else: messagebox.showerror("Error", f"Failed to apply settings: {response.text}") except requests.exceptions.RequestException: messagebox.showwarning("Warning", "Server not responding. Settings will be applied on next restart.") except Exception as e: messagebox.showerror("Error", f"Failed to apply settings: {str(e)}") def apply_preset(self, gpu, cpu, io, threads): """Apply preset configuration""" self.gpu_var.set(str(gpu)) self.cpu_var.set(str(cpu)) self.io_var.set(str(io)) self.thread_var.set(str(threads)) self.apply_settings() def reset_settings(self): """Reset to default settings""" self.gpu_var.set("2") self.cpu_var.set("4") self.io_var.set("6") self.thread_var.set("6") def show_presets(self): """Show preset explanations""" presets_info = """ Performance Presets: • Light (1,2,3,3): Minimal resource usage, good for testing • Balanced (2,4,6,6): Default configuration, good performance • Performance (3,6,8,8): High performance, more resource usage • Max (4,8,10,12): Maximum performance, highest resource usage Note: Higher values = better performance but more resource usage """ messagebox.showinfo("Presets Info", presets_info) def check_server_status(self): """Check server status""" try: response = requests.get(f"{self.server_url}/health", timeout=3) if response.status_code == 200: data = response.json() status_text = f"✅ Server Online | Model: {data.get('model_status', 'unknown')}" if 'async_resources' in data: async_info = data['async_resources'] status_text += f" | GPU: {async_info.get('gpu_available', 0)}" status_text += f" | CPU: {async_info.get('cpu_available', 0)}" status_text += f" | I/O: {async_info.get('io_available', 0)}" self.status_label.config(text=status_text, foreground="green") return True else: self.status_label.config(text="❌ Server Error", foreground="red") return False except Exception: self.status_label.config(text="❌ Server Offline", foreground="red") return False def update_current_settings_display(self): """Update current settings display""" settings_text = f"""GPU Semaphore: {self.current_settings['gpu_semaphore']} (concurrent GPU tasks) CPU Semaphore: {self.current_settings['cpu_semaphore']} (concurrent CPU tasks) I/O Semaphore: {self.current_settings['io_semaphore']} (concurrent I/O tasks) Thread Pool: {self.current_settings['thread_pool']} (worker threads)""" self.current_settings_text.config(state="normal") self.current_settings_text.delete(1.0, tk.END) self.current_settings_text.insert(1.0, settings_text) self.current_settings_text.config(state="disabled") def refresh_monitor(self): """Refresh monitor data""" try: # Get detailed status response = requests.get(f"{self.server_url}/status", timeout=3) if response.status_code == 200: data = response.json() resource_info = "=== RESOURCE USAGE ===\n" if 'async_processing' in data: async_data = data['async_processing'] for resource, info in async_data.items(): usage_pct = (info['in_use'] / info['max_capacity']) * 100 resource_info += f"{resource}: {info['in_use']}/{info['max_capacity']} ({usage_pct:.0f}% used)\n" if 'model_info' in data: model_info = data['model_info'] resource_info += f"\nModel: {model_info.get('device', 'unknown')}\n" resource_info += f"Cache: {model_info.get('reference_cache_size', 0)} voices cached\n" resource_info += f"\nLast Updated: {datetime.now().strftime('%H:%M:%S')}" self.resource_text.config(state="normal") self.resource_text.delete(1.0, tk.END) self.resource_text.insert(1.0, resource_info) self.resource_text.config(state="disabled") except requests.exceptions.RequestException: # Don't log connection errors to avoid spam pass except Exception as e: self.log_activity(f"Monitor error: {str(e)}") def clear_monitor_display(self): """Clear monitor display when server is offline""" offline_info = "=== SERVER OFFLINE ===\n\nServer is not running.\nUse 'Start Server' button to launch the server.\n\nMonitoring will resume when server is online." self.resource_text.config(state="normal") self.resource_text.delete(1.0, tk.END) self.resource_text.insert(1.0, offline_info) self.resource_text.config(state="disabled") def log_activity(self, message): """Log activity to monitor""" timestamp = datetime.now().strftime("%H:%M:%S") log_message = f"[{timestamp}] {message}\n" self.activity_text.config(state="normal") self.activity_text.insert(tk.END, log_message) self.activity_text.see(tk.END) self.activity_text.config(state="disabled") # Keep only last 100 lines lines = self.activity_text.get(1.0, tk.END).split('\n') if len(lines) > 100: self.activity_text.config(state="normal") self.activity_text.delete(1.0, f"{len(lines)-100}.0") self.activity_text.config(state="disabled") def start_monitoring(self): """Start monitoring loop""" def monitor_loop(): while True: server_online = self.check_server_status() # Only refresh monitor if server is online and auto refresh is enabled if server_online and self.auto_refresh_var.get(): self.refresh_monitor() elif not server_online: # Clear monitor display when server is offline self.clear_monitor_display() time.sleep(10) # Update every 10 seconds to reduce spam threading.Thread(target=monitor_loop, daemon=True).start() # Initial updates self.update_current_settings_display() def open_api_docs(self): """Open API documentation""" import webbrowser webbrowser.open(f"{self.server_url}/docs") def test_server(self): """Quick server test""" try: test_data = { "text": "Test server connection", "voice_choice": "Tuyên (nam miền Bắc)", "speed_factor": 1.0 } self.log_activity("Testing server...") response = requests.post(f"{self.server_url}/tts", json=test_data, timeout=30) if response.status_code == 200: result = response.json() self.log_activity(f"✅ Server test successful! Processing time: {result.get('processing_time', 0):.2f}s") else: self.log_activity(f"❌ Server test failed: HTTP {response.status_code}") except Exception as e: self.log_activity(f"❌ Server test error: {str(e)}") def clear_cache(self): """Clear server cache""" try: response = requests.post(f"{self.server_url}/admin/clear_cache", timeout=5) if response.status_code == 200: self.log_activity("✅ Cache cleared successfully") else: self.log_activity("❌ Failed to clear cache") except Exception as e: self.log_activity(f"❌ Cache clear error: {str(e)}") def main(): root = tk.Tk() app = ServerManager(root) root.mainloop() if __name__ == "__main__": main()