jettask 0.2.8__tar.gz → 0.2.13__tar.gz

{jettask-0.2.8/jettask.egg-info → jettask-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jettask
-Version: 0.2.8
+Version: 0.2.13
 Summary: A high-performance distributed task queue system with web monitoring
 Author-email: JetTask Team <support@jettask.io>
 License-Expression: MIT

{jettask-0.2.8 → jettask-0.2.13}/jettask/core/cli.py

@@ -475,28 +475,32 @@ def scheduler(task_center, interval, batch_size, check_interval, debug):
         click.echo("\nShutdown complete")
 
 @cli.command()
-@click.option('--port', default=5173, help='前端开发服务器端口')
-@click.option('--host', default='0.0.0.0', help='前端开发服务器监听地址')
+@click.option('--port', default=8080, help='前端服务器端口')
+@click.option('--host', default='0.0.0.0', help='前端服务器监听地址')
+@click.option('--api-url', default='http://localhost:8001', help='后端 API 服务器地址')
 @click.option('--auto-install', is_flag=True, default=True, help='自动安装缺失的依赖')
 @click.option('--force-install', is_flag=True, help='强制重新安装依赖')
-@click.option('--build', is_flag=True, help='构建生产版本而不是启动开发服务器')
-def frontend(port, host, auto_install, force_install, build):
+@click.option('--build-only', is_flag=True, help='仅构建生产版本，不启动服务器')
+def frontend(port, host, api_url, auto_install, force_install, build_only):
     """启动 WebUI 前端界面
     
-    自动检测环境并启动前端开发服务器：
+    启动生产版本服务器：
     1. 检查 Node.js 和 npm 是否安装
-    2. 自动安装缺失的依赖
-    3. 启动开发服务器或构建生产版本
+    2. 在包目录安装依赖并构建
+    3. 启动生产版本服务器
     
     示例：
-      # 启动开发服务器（默认）
+      # 启动生产版本服务器（默认）
       jettask frontend
       
       # 指定端口
       jettask frontend --port 3000
       
-      # 构建生产版本
-      jettask frontend --build
+      # 指定后端API地址
+      jettask frontend --api-url http://192.168.1.100:8001
+      
+      # 仅构建生产版本
+      jettask frontend --build-only
       
       # 强制重新安装依赖
       jettask frontend --force-install
@@ -541,7 +545,7 @@ def frontend(port, host, auto_install, force_install, build):
     
     # 切换到前端目录
     os.chdir(frontend_dir)
-    click.echo(f"切换到前端目录: {frontend_dir}")
+    click.echo(f"前端目录: {frontend_dir}")
     
     # 检查 package.json 是否存在
     package_json = frontend_dir / "package.json"
@@ -583,48 +587,185 @@ def frontend(port, host, auto_install, force_install, build):
     
     # 构建或启动
     try:
-        if build:
-            # 构建生产版本
+        # 构建生产版本
+        # 注意：根据 vite.config.js，构建输出到 ../static/dist
+        dist_dir = frontend_dir.parent / "static" / "dist"
+        
+        # 检查是否需要构建
+        need_build = not dist_dir.exists() or build_only
+        
+        # 如果 dist 不存在或明确要求构建，则进行构建
+        if need_build:
             click.echo("\n正在构建生产版本...")
             subprocess.run([npm_cmd, 'run', 'build'], check=True)
             
-            # 显示构建结果
-            dist_dir = frontend_dir.parent / "static" / "dist"
             if dist_dir.exists():
-                click.echo(f"\n✓ 构建完成！输出目录: {dist_dir}")
                 # 统计文件
                 files = list(dist_dir.rglob('*'))
                 file_count = len([f for f in files if f.is_file()])
                 total_size = sum(f.stat().st_size for f in files if f.is_file())
+                click.echo(f"\n✓ 构建完成！")
+                click.echo(f"  - 输出目录: {dist_dir}")
                 click.echo(f"  - 文件数量: {file_count}")
                 click.echo(f"  - 总大小: {total_size / 1024 / 1024:.2f} MB")
             else:
-                click.echo("警告：构建完成但未找到输出目录")
-        else:
-            # 启动开发服务器
-            click.echo(f"\n正在启动前端开发服务器...")
-            click.echo(f"  - 地址: http://{host}:{port}")
-            click.echo(f"  - 本地访问: http://localhost:{port}")
-            click.echo("\n按 Ctrl+C 停止服务器\n")
+                click.echo("错误：构建失败，未生成输出目录", err=True)
+                sys.exit(1)
+        
+        # 如果不是仅构建模式，启动生产服务器
+        if not build_only:
+            if not dist_dir.exists():
+                click.echo("错误：未找到构建输出，请先运行构建", err=True)
+                sys.exit(1)
             
-            # 构建启动命令
-            cmd = [npm_cmd, 'run', 'dev']
+            click.echo(f"\n正在启动生产版本服务器...")
+            click.echo(f"  - 访问地址: http://localhost:{port}")
             if host != 'localhost':
-                cmd.extend(['--', '--host', host])
-            if port != 5173:
-                cmd.extend(['--port', str(port)])
+                click.echo(f"  - 网络地址: http://{host}:{port}")
+            click.echo(f"  - 静态文件: {dist_dir}")
+            click.echo(f"  - API 地址: {api_url}")
+            click.echo("\n按 Ctrl+C 停止服务器\n")
+            
+            # 使用 Python 内置的 HTTP 服务器提供静态文件
+            import http.server
+            import socketserver
+            import urllib.request
+            import urllib.parse
+            import json
+            
+            class ProxyHandler(http.server.SimpleHTTPRequestHandler):
+                def __init__(self, *args, **kwargs):
+                    super().__init__(*args, directory=str(dist_dir), **kwargs)
+                
+                def proxy_request(self, method='GET', body=None):
+                    """代理 API 请求到后端服务器"""
+                    if self.path.startswith('/api/') or self.path.startswith('/ws/'):
+                        # 构建目标 URL
+                        target_url = api_url + self.path
+                        
+                        try:
+                            # 准备请求
+                            req = urllib.request.Request(target_url, method=method)
+                            
+                            # 复制请求头
+                            for header, value in self.headers.items():
+                                if header.lower() not in ['host', 'connection']:
+                                    req.add_header(header, value)
+                            
+                            # 添加请求体
+                            if body:
+                                req.data = body
+                            
+                            # 发送请求
+                            with urllib.request.urlopen(req, timeout=30) as response:
+                                # 返回响应
+                                self.send_response(response.getcode())
+                                for header, value in response.headers.items():
+                                    if header.lower() not in ['connection', 'transfer-encoding']:
+                                        self.send_header(header, value)
+                                self.end_headers()
+                                self.wfile.write(response.read())
+                            return True
+                            
+                        except urllib.error.HTTPError as e:
+                            self.send_response(e.code)
+                            self.end_headers()
+                            self.wfile.write(e.read())
+                            return True
+                        except Exception as e:
+                            self.send_error(502, f"Bad Gateway: {str(e)}")
+                            return True
+                    return False
+                
+                def do_GET(self):
+                    # 先尝试代理 API 请求
+                    if self.proxy_request('GET'):
+                        return
+                    
+                    # 对于 index.html，注入 API URL
+                    if self.path == '/' or self.path == '/index.html' or (
+                        self.path != '/' and not Path(dist_dir / self.path[1:]).exists()
+                    ):
+                        # 读取 index.html
+                        index_path = dist_dir / 'index.html'
+                        if index_path.exists():
+                            with open(index_path, 'r', encoding='utf-8') as f:
+                                html_content = f.read()
+                            
+                            # 注入 API URL 配置（使用相对路径，因为我们会代理）
+                            api_config = f'''
+                            <script>
+                                window.JETTASK_API_URL = '';  // 使用相对路径，由服务器代理
+                                console.log('API requests will be proxied by server');
+                            </script>
+                            '''
+                            
+                            # 在 </head> 标签前注入配置
+                            html_content = html_content.replace('</head>', api_config + '</head>')
+                            
+                            # 发送响应
+                            self.send_response(200)
+                            self.send_header('Content-type', 'text/html')
+                            self.send_header('Content-Length', str(len(html_content.encode('utf-8'))))
+                            self.end_headers()
+                            self.wfile.write(html_content.encode('utf-8'))
+                            return
+                    
+                    # 其他文件正常处理
+                    return super().do_GET()
+                
+                def do_POST(self):
+                    # 读取请求体
+                    content_length = int(self.headers.get('Content-Length', 0))
+                    body = self.rfile.read(content_length) if content_length > 0 else None
+                    
+                    # 代理 POST 请求
+                    if self.proxy_request('POST', body):
+                        return
+                    
+                    # 不支持的请求
+                    self.send_error(405, "Method Not Allowed")
+                
+                def do_PUT(self):
+                    content_length = int(self.headers.get('Content-Length', 0))
+                    body = self.rfile.read(content_length) if content_length > 0 else None
+                    if self.proxy_request('PUT', body):
+                        return
+                    self.send_error(405, "Method Not Allowed")
+                
+                def do_DELETE(self):
+                    if self.proxy_request('DELETE'):
+                        return
+                    self.send_error(405, "Method Not Allowed")
+                
+                def log_message(self, format, *args):
+                    # 自定义日志格式
+                    click.echo(f"[{self.log_date_time_string()}] {format % args}")
+            
+            # 创建服务器
+            class ReuseAddrTCPServer(socketserver.TCPServer):
+                allow_reuse_address = True
+                allow_reuse_port = True
             
-            # 启动开发服务器
-            process = subprocess.Popen(cmd)
-            process.wait()
+            try:
+                click.echo(f"正在绑定到 {host}:{port}...")
+                httpd = ReuseAddrTCPServer((host, port), ProxyHandler)
+                click.echo(f"✓ 服务器已启动，监听 {host}:{port}")
+                click.echo(f"✓ API 请求将被代理到 {api_url}")
+                httpd.serve_forever()
+            except OSError as e:
+                if e.errno == 98:  # Address already in use
+                    click.echo(f"错误：端口 {port} 已被占用，请尝试其他端口", err=True)
+                else:
+                    click.echo(f"错误：{e}", err=True)
+                sys.exit(1)
+            except KeyboardInterrupt:
+                pass
     except subprocess.CalledProcessError as e:
         click.echo(f"错误：命令执行失败 - {e}", err=True)
         sys.exit(1)
     except KeyboardInterrupt:
         click.echo("\n停止前端服务器")
-        if 'process' in locals():
-            process.terminate()
-            process.wait()
 
 def main():
     """主入口函数"""

{jettask-0.2.8 → jettask-0.2.13}/jettask/webui/backend/namespace_data_access.py

@@ -181,35 +181,62 @@ class NamespaceDataAccessManager:
     
     async def get_namespace_config(self, namespace_name: str) -> dict:
         """从任务中心API获取命名空间配置"""
-        url = f"{self.task_center_base_url}/api/namespaces/{namespace_name}"
-        
+        # 直接从数据库获取，而不是通过HTTP调用自己
+        # 这避免了循环依赖和网络问题
         try:
-            session = await self._get_session()
-            async with session.get(url) as resp:
-                if resp.status == 200:
-                    data = await resp.json()
-                    # API返回的是redis_config和pg_config，直接使用
-                    redis_config = data.get('redis_config', {})
-                    pg_config = data.get('pg_config', {})
-                    
-                    # 兼容旧格式：如果有redis_url和pg_url字段
-                    if not redis_config and data.get('redis_url'):
-                        redis_config = {'url': data.get('redis_url')}
-                    
-                    if not pg_config and data.get('pg_url'):
-                        pg_config = {'url': data.get('pg_url')}
-                    
+            # 先尝试从缓存或直接数据库访问
+            from jettask.webui.backend.models import NamespaceModel
+            from jettask.webui.backend.db_init import get_async_session
+            from sqlalchemy import select
+            
+            async with get_async_session() as session:
+                stmt = select(NamespaceModel).where(NamespaceModel.name == namespace_name)
+                result = await session.execute(stmt)
+                namespace = result.scalar_one_or_none()
+                
+                if namespace:
                     return {
-                        'name': data.get('name'),
-                        'redis_config': redis_config,
-                        'pg_config': pg_config
+                        'name': namespace.name,
+                        'redis_config': namespace.redis_config or {},
+                        'pg_config': namespace.pg_config or {}
                     }
                 else:
-                    raise ValueError(f"无法获取命名空间 {namespace_name} 的配置: HTTP {resp.status}")
-        except Exception as e:
-            logger.error(f"获取命名空间 {namespace_name} 配置失败: {e}")
-            traceback.print_exc()
-            raise
+                    raise ValueError(f"命名空间 {namespace_name} 不存在")
+        except (ImportError, Exception) as e:
+            # 如果无法直接访问数据库，则通过HTTP调用（但使用127.0.0.1）
+            logger.warning(f"直接数据库访问失败，回退到HTTP调用: {e}")
+            base_url = self.task_center_base_url
+            if 'localhost' in base_url:
+                base_url = base_url.replace('localhost', '127.0.0.1')
+            url = f"{base_url}/api/namespaces/{namespace_name}"
+            
+            try:
+                session = await self._get_session()
+                async with session.get(url) as resp:
+                    if resp.status == 200:
+                        data = await resp.json()
+                        # API返回的是redis_config和pg_config，直接使用
+                        redis_config = data.get('redis_config', {})
+                        pg_config = data.get('pg_config', {})
+                        
+                        # 兼容旧格式：如果有redis_url和pg_url字段
+                        if not redis_config and data.get('redis_url'):
+                            redis_config = {'url': data.get('redis_url')}
+                        
+                        if not pg_config and data.get('pg_url'):
+                            pg_config = {'url': data.get('pg_url')}
+                        
+                        return {
+                            'name': data.get('name'),
+                            'redis_config': redis_config,
+                            'pg_config': pg_config
+                        }
+                    else:
+                        raise ValueError(f"无法获取命名空间 {namespace_name} 的配置: HTTP {resp.status}")
+            except Exception as e:
+                logger.error(f"通过HTTP获取命名空间 {namespace_name} 配置失败: {e}")
+                traceback.print_exc()
+                raise
     
     async def get_connection(self, namespace_name: str) -> NamespaceConnection:
         """

{jettask-0.2.8 → jettask-0.2.13}/jettask/webui/frontend/src/main.jsx

@@ -7,6 +7,8 @@ import 'dayjs/locale/zh-cn'
 import App from './App'
 import './index.css'
 import './utils/suppressWarnings'
+// 初始化 API 配置（必须在其他组件之前）
+import './services/api'
 
 // 设置 dayjs 为中文
 dayjs.locale('zh-cn')

{jettask-0.2.8 → jettask-0.2.13}/jettask/webui/frontend/src/pages/ScheduledTasks.jsx

@@ -102,8 +102,9 @@ function ScheduledTasks() {
         offset: (params.current - 1) * params.pageSize,
       };
 
+      const apiBase = window.JETTASK_API_URL || 'http://localhost:8001';
       const response = await axios.get(
-        `http://localhost:8001/api/data/scheduled-tasks/${currentNamespace}`,
+        `${apiBase}/api/data/scheduled-tasks/${currentNamespace}`,
         { params: requestParams }
       );
 

{jettask-0.2.8 → jettask-0.2.13}/jettask/webui/frontend/src/pages/Settings.jsx

@@ -161,7 +161,8 @@ function Settings() {
         refreshNamespaceList();  // 触发全局命名空间列表刷新
         
         // 显示连接URL
-        const fullUrl = `http://localhost:8001${response.data.connection_url}`;
+        const apiBase = window.JETTASK_API_URL || 'http://localhost:8001';
+        const fullUrl = `${apiBase}${response.data.connection_url}`;
         Modal.success({
           title: '命名空间创建成功',
           content: (

{jettask-0.2.8 → jettask-0.2.13}/jettask/webui/frontend/src/services/api.js

@@ -2,6 +2,17 @@ import axios from 'axios';
 
 // 智能获取 API 基础 URL
 const getApiBaseUrl = () => {
+  // 优先使用注入的 API URL
+  if (typeof window !== 'undefined' && window.JETTASK_API_URL !== undefined) {
+    const url = window.JETTASK_API_URL;
+    // 如果是空字符串，表示使用相对路径（代理模式）
+    if (url === '') {
+      return '';  // 使用相对路径，不加前缀
+    }
+    // 否则确保 URL 以 /api 结尾
+    return url.endsWith('/api') ? url : `${url}/api`;
+  }
+  
   // 在开发环境中使用 localhost
   if (typeof window !== 'undefined') {
     const hostname = window.location.hostname;
@@ -19,6 +30,19 @@ const getApiBaseUrl = () => {
 
 // 智能获取 WebSocket URL
 const getWsBaseUrl = () => {
+  // 优先使用注入的 API URL
+  if (typeof window !== 'undefined' && window.JETTASK_API_URL !== undefined) {
+    const url = window.JETTASK_API_URL;
+    // 如果是空字符串，使用相对路径
+    if (url === '') {
+      const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+      return `${wsProtocol}//${window.location.host}/ws`;
+    }
+    // 将 http 转换为 ws，https 转换为 wss
+    const wsUrl = url.replace(/^http/, 'ws');
+    return wsUrl.endsWith('/ws') ? wsUrl : `${wsUrl}/ws`;
+  }
+  
   if (typeof window !== 'undefined') {
     const hostname = window.location.hostname;
     const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -36,16 +60,37 @@ const getWsBaseUrl = () => {
 const API_BASE_URL = getApiBaseUrl();
 const WS_BASE_URL = getWsBaseUrl();
 
+// 设置 axios 全局默认配置
+// 空字符串时不设置 baseURL，让 axios 使用相对路径
+if (API_BASE_URL !== '') {
+  axios.defaults.baseURL = API_BASE_URL;
+}
+
 // 创建 axios 实例
+// 如果 baseURL 为空，设置一个请求拦截器来处理路径
 const api = axios.create({
-  baseURL: API_BASE_URL,
+  baseURL: API_BASE_URL === '' ? undefined : API_BASE_URL,  // 空字符串时不设置 baseURL
   timeout: 10000,
 });
 
+// 如果是代理模式，确保路径正确
+if (API_BASE_URL === '') {
+  api.interceptors.request.use(config => {
+    // 确保路径以 /api/ 开头
+    if (!config.url.startsWith('/api/')) {
+      config.url = '/api/' + config.url;
+    }
+    return config;
+  });
+}
+
+// 导出配置好的实例和URLs
+export { api, API_BASE_URL, WS_BASE_URL };
+
 // 获取全局统计信息
 export const fetchGlobalStats = async () => {
   try {
-    const response = await api.get('/stats');
+    const response = await api.get('stats');  // 不要前导斜杠，axios 会自动处理
     return response.data.data;
   } catch (error) {
     console.error('Failed to fetch global stats:', error);
@@ -56,7 +101,7 @@ export const fetchGlobalStats = async () => {
 // 获取队列列表
 export const fetchQueues = async () => {
   try {
-    const response = await api.get('/queues');
+    const response = await api.get('queues');  // 不要前导斜杠
     return response.data;
   } catch (error) {
     console.error('Failed to fetch queues:', error);
@@ -69,7 +114,7 @@ export const fetchQueueTimeline = async (params) => {
   try {
     // 从参数中提取命名空间，如果没有则使用 default
     const namespace = params.namespace || 'default';
-    const response = await api.post(`/queue-timeline/${namespace}`, params);
+    const response = await api.post(`queue-timeline/${namespace}`, params);  // 不要前导斜杠
     // 处理数据，确保不包含填充的空值
     const data = response.data.data || response.data || [];
     return {

{jettask-0.2.8 → jettask-0.2.13}/jettask/webui/frontend/src/services/queueTrend.js

@@ -3,6 +3,16 @@ import axios from 'axios';
 // 在 React 应用中，环境变量需要以 REACT_APP_ 开头
 // 使用 window.location 作为后备方案
 const getApiBaseUrl = () => {
+  // 优先使用注入的 API URL
+  if (typeof window !== 'undefined' && window.JETTASK_API_URL !== undefined) {
+    const url = window.JETTASK_API_URL;
+    // 如果是空字符串，表示使用相对路径（代理模式）
+    if (url === '') {
+      return '';  // 使用相对路径
+    }
+    return url;
+  }
+  
   // 尝试从环境变量获取（Create React App 会在构建时注入）
   if (typeof window !== 'undefined' && window.REACT_APP_API_URL) {
     return window.REACT_APP_API_URL;
@@ -39,7 +49,9 @@ export const fetchQueueTrend = async (timeRange = '1h', queues = [], customTimeR
       params.end = customTimeRange[1].valueOf();
     }
 
-    const response = await axios.get(`${API_BASE_URL}/api/queue-trend`, { params });
+    // 当 API_BASE_URL 为空时，使用相对路径；否则需要加 /api
+    const url = API_BASE_URL === '' ? '/api/queue-trend' : `${API_BASE_URL}/api/queue-trend`;
+    const response = await axios.get(url, { params });
     
     // 处理响应数据 - 后端现在直接返回时间线数据
     const data = response.data.data || response.data || [];
@@ -132,7 +144,9 @@ const getIntervalByRange = (range) => {
  */
 export const fetchQueueStats = async (queueName, timeRange = '1h') => {
   try {
-    const response = await axios.get(`${API_BASE_URL}/api/queue/${queueName}/stats`, {
+    // 当 API_BASE_URL 为空时，使用相对路径；否则需要加 /api
+    const url = API_BASE_URL === '' ? `/api/queue/${queueName}/stats` : `${API_BASE_URL}/api/queue/${queueName}/stats`;
+    const response = await axios.get(url, {
       params: { range: timeRange }
     });
     

{jettask-0.2.8 → jettask-0.2.13/jettask.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jettask
-Version: 0.2.8
+Version: 0.2.13
 Summary: A high-performance distributed task queue system with web monitoring
 Author-email: JetTask Team <support@jettask.io>
 License-Expression: MIT

{jettask-0.2.8 → jettask-0.2.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jettask"
-version = "0.2.8"
+version = "0.2.13"
 authors = [
     {name = "JetTask Team", email = "support@jettask.io"},
 ]