174 lines
8.1 KiB
Python
174 lines
8.1 KiB
Python
import gradio as gr
|
|
import tempfile
|
|
from pathlib import Path
|
|
from typing import TYPE_CHECKING
|
|
|
|
if TYPE_CHECKING:
|
|
from .proxy_manager import ProxyManager
|
|
|
|
def create_proxy_interface(proxy_manager: 'ProxyManager'):
|
|
"""Create the proxy management interface"""
|
|
config = proxy_manager.config_manager.get_instance()
|
|
|
|
def validate_ports(gradio_port, api_port):
|
|
"""Validate port configurations"""
|
|
if gradio_port == api_port and gradio_port != 0 and api_port != 0:
|
|
return False, "Gradio and API ports cannot be the same!"
|
|
if not (0 <= gradio_port <= 65535) or not (0 <= api_port <= 65535):
|
|
return False, "Ports must be between 0 and 65535"
|
|
return True, "Valid port configuration"
|
|
|
|
def handle_save_config(proxy_enabled, gradio_enabled, api_enabled,
|
|
gradio_port, api_port, startup, external_ip):
|
|
# Validate ports first
|
|
valid, message = validate_ports(gradio_port, api_port)
|
|
if not valid:
|
|
return message
|
|
|
|
config.proxy_settings.proxy_enabled = proxy_enabled
|
|
config.proxy_settings.start_on_startup = startup
|
|
|
|
# Update Gradio endpoint
|
|
config.proxy_settings.gradio_endpoint.enabled = gradio_enabled
|
|
config.proxy_settings.gradio_endpoint.external_port = int(gradio_port) if gradio_enabled else 0
|
|
config.proxy_settings.gradio_endpoint.external_ip = external_ip
|
|
|
|
# Update API endpoint
|
|
config.proxy_settings.api_endpoint.enabled = api_enabled
|
|
config.proxy_settings.api_endpoint.external_port = int(api_port) if api_enabled else 0
|
|
config.proxy_settings.api_endpoint.external_ip = external_ip
|
|
|
|
config.save()
|
|
return "Configuration saved successfully"
|
|
|
|
def update_control_states(proxy_enabled):
|
|
"""Update enabled/disabled state of controls based on master switch"""
|
|
return {
|
|
start_button: gr.update(interactive=proxy_enabled),
|
|
stop_button: gr.update(interactive=proxy_enabled),
|
|
gradio_enabled: gr.update(interactive=proxy_enabled),
|
|
api_enabled: gr.update(interactive=proxy_enabled),
|
|
start_on_startup: gr.update(interactive=proxy_enabled)
|
|
}
|
|
|
|
def delete_all_certificates():
|
|
"""Delete all certificates and reset config"""
|
|
try:
|
|
# Delete certificate files
|
|
for cert_file in proxy_manager.certs_path.glob("*.pem"):
|
|
cert_file.unlink()
|
|
|
|
# Reset config
|
|
config = proxy_manager.config_manager.get_instance()
|
|
config.proxy_settings.gradio_endpoint.cert_name = ""
|
|
config.proxy_settings.api_endpoint.cert_name = ""
|
|
config.save()
|
|
|
|
return "All certificates deleted and config reset"
|
|
except Exception as e:
|
|
return f"Error deleting certificates: {str(e)}"
|
|
|
|
with gr.Tab("Proxy Settings"):
|
|
with gr.Column():
|
|
with gr.Row():
|
|
with gr.Group():
|
|
proxy_enabled = gr.Checkbox(
|
|
label="Enable Proxy System",
|
|
value=config.proxy_settings.proxy_enabled,
|
|
info="Master switch/safety lockout for proxy functionality"
|
|
)
|
|
start_on_startup = gr.Checkbox(
|
|
label="Start Proxy Automatically on Startup",
|
|
value=config.proxy_settings.start_on_startup,
|
|
info="Automatically start proxy when app launches"
|
|
)
|
|
external_ip = gr.Textbox(
|
|
label="External IP",
|
|
value=config.proxy_settings.gradio_endpoint.external_ip,
|
|
info="Use 0.0.0.0 to bind to all interfaces"
|
|
)
|
|
with gr.Group():
|
|
gr.Markdown("API interface Proxy Management")
|
|
api_enabled = gr.Dropdown(
|
|
choices=["Enabled", "Disabled"],
|
|
value="Enabled" if config.proxy_settings.api_endpoint.enabled == "Enabled" else "Disabled",
|
|
label="API (TTS Generation) Proxy",
|
|
info="Enable or Disable Proxying the API (TTS Generation)"
|
|
)
|
|
api_port = gr.Number(
|
|
value=config.proxy_settings.api_endpoint.external_port,
|
|
label="API Port",
|
|
info="External port you want to use for the API (TTS Generation)"
|
|
)
|
|
with gr.Group():
|
|
gr.Markdown("Gradio interface Proxy Management")
|
|
gradio_enabled = gr.Dropdown(
|
|
choices=["Enabled", "Disabled"],
|
|
value="Enabled" if config.proxy_settings.gradio_endpoint.enabled == "Enabled" else "Disabled",
|
|
label="Gradio Interface Proxy",
|
|
info="Enable or Disable Proxying the Gradio interface"
|
|
)
|
|
gradio_port = gr.Number(
|
|
value=config.proxy_settings.gradio_endpoint.external_port,
|
|
label="Gradio Interface Port",
|
|
info="External port you want to use for the Gradio interface"
|
|
)
|
|
|
|
# Status and control section
|
|
with gr.Row():
|
|
with gr.Column(scale=2):
|
|
status_output = gr.Textbox(
|
|
label="Status",
|
|
interactive=False,
|
|
lines=4
|
|
)
|
|
with gr.Column(scale=1):
|
|
save_button = gr.Button("Save Configuration", variant="primary")
|
|
with gr.Row():
|
|
start_button = gr.Button("Start Service")
|
|
stop_button = gr.Button("Stop Service")
|
|
status_button = gr.Button("Check Status")
|
|
|
|
# Certificate section
|
|
with gr.Row():
|
|
gr.Markdown("### Certificate Management")
|
|
with gr.Row():
|
|
with gr.Column(scale=1):
|
|
cert_file = gr.File(label="Certificate (.crt/.pem)")
|
|
with gr.Column(scale=1):
|
|
key_file = gr.File(label="Key (.key)")
|
|
with gr.Column(scale=1):
|
|
cert_name = gr.Textbox(label="Certificate Name", placeholder="e.g., gradio_cert")
|
|
upload_button = gr.Button("Upload Certificate", variant="primary")
|
|
delete_button = gr.Button("Delete Certificates", variant="secondary")
|
|
|
|
# Connect everything
|
|
save_button.click(
|
|
fn=handle_save_config,
|
|
inputs=[
|
|
proxy_enabled,
|
|
gradio_enabled,
|
|
api_enabled,
|
|
gradio_port,
|
|
api_port,
|
|
start_on_startup,
|
|
external_ip
|
|
],
|
|
outputs=status_output
|
|
)
|
|
proxy_enabled.change(
|
|
fn=update_control_states,
|
|
inputs=[proxy_enabled],
|
|
outputs=[start_button, stop_button, gradio_enabled, api_enabled, start_on_startup]
|
|
)
|
|
start_button.click(fn=proxy_manager.start_proxy, outputs=status_output)
|
|
stop_button.click(fn=proxy_manager.stop_proxy, outputs=status_output)
|
|
status_button.click(fn=proxy_manager.get_status, outputs=status_output)
|
|
upload_button.click(
|
|
fn=proxy_manager.handle_cert_upload,
|
|
inputs=[cert_file, key_file, cert_name],
|
|
outputs=status_output
|
|
)
|
|
delete_button.click(fn=delete_all_certificates, outputs=status_output)
|
|
|
|
return proxy_enabled, start_on_startup, gradio_port, api_port |