jettask 0.2.9__tar.gz → 0.2.13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jettask
-Version: 0.2.9
+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.9 → jettask-0.2.13}/jettask/core/cli.py

@@ -477,16 +477,17 @@ def scheduler(task_center, interval, batch_size, check_interval, debug):
 @cli.command()
 @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-only', is_flag=True, help='仅构建生产版本，不启动服务器')
-def frontend(port, host, auto_install, force_install, build_only):
+def frontend(port, host, api_url, auto_install, force_install, build_only):
     """启动 WebUI 前端界面
     
     启动生产版本服务器：
     1. 检查 Node.js 和 npm 是否安装
-    2. 复制前端代码到用户目录并安装依赖
-    3. 构建并启动生产版本服务器
+    2. 在包目录安装依赖并构建
+    3. 启动生产版本服务器
     
     示例：
       # 启动生产版本服务器（默认）
@@ -495,6 +496,9 @@ def frontend(port, host, auto_install, force_install, build_only):
       # 指定端口
       jettask frontend --port 3000
       
+      # 指定后端API地址
+      jettask frontend --api-url http://192.168.1.100:8001
+      
       # 仅构建生产版本
       jettask frontend --build-only
       
@@ -505,79 +509,12 @@ def frontend(port, host, auto_install, force_install, build_only):
     import shutil
     from pathlib import Path
     
-    # 获取源前端目录路径（包中的）
-    source_frontend_dir = Path(__file__).parent.parent / "webui" / "frontend"
-    if not source_frontend_dir.exists():
-        click.echo(f"错误：前端源目录不存在: {source_frontend_dir}", err=True)
+    # 获取前端目录路径
+    frontend_dir = Path(__file__).parent.parent / "webui" / "frontend"
+    if not frontend_dir.exists():
+        click.echo(f"错误：前端目录不存在: {frontend_dir}", err=True)
         sys.exit(1)
     
-    # 获取用户工作目录（在用户主目录下）
-    user_home = Path.home()
-    user_jettask_dir = user_home / ".jettask"
-    user_frontend_dir = user_jettask_dir / "frontend"
-    
-    # 确保用户目录存在
-    user_jettask_dir.mkdir(parents=True, exist_ok=True)
-    
-    # 检查是否需要复制/更新前端代码
-    should_copy = False
-    if not user_frontend_dir.exists():
-        should_copy = True
-        click.echo(f"首次使用，正在初始化前端环境...")
-    else:
-        # 检查版本或时间戳来决定是否需要更新
-        source_package_json = source_frontend_dir / "package.json"
-        user_package_json = user_frontend_dir / "package.json"
-        if not user_package_json.exists():
-            should_copy = True
-        else:
-            # 比较修改时间
-            if source_package_json.stat().st_mtime > user_package_json.stat().st_mtime:
-                should_copy = True
-                click.echo("检测到前端代码更新，正在同步...")
-    
-    if should_copy:
-        # 复制前端代码到用户目录
-        if user_frontend_dir.exists():
-            # 保留 node_modules 和 dist 目录
-            node_modules_backup = None
-            dist_backup = None
-            
-            node_modules_dir = user_frontend_dir / "node_modules"
-            dist_dir = user_frontend_dir / "dist"
-            
-            if node_modules_dir.exists() and not force_install:
-                # 备份 node_modules
-                node_modules_backup = user_jettask_dir / "node_modules_backup"
-                if node_modules_backup.exists():
-                    shutil.rmtree(node_modules_backup)
-                shutil.move(str(node_modules_dir), str(node_modules_backup))
-            
-            if dist_dir.exists():
-                # 备份 dist
-                dist_backup = user_jettask_dir / "dist_backup"
-                if dist_backup.exists():
-                    shutil.rmtree(dist_backup)
-                shutil.move(str(dist_dir), str(dist_backup))
-            
-            # 删除旧的前端目录
-            shutil.rmtree(user_frontend_dir)
-        
-        # 复制新的前端代码
-        shutil.copytree(source_frontend_dir, user_frontend_dir, ignore=shutil.ignore_patterns('node_modules', 'dist', '.git'))
-        
-        # 恢复备份
-        if 'node_modules_backup' in locals() and node_modules_backup and node_modules_backup.exists():
-            shutil.move(str(node_modules_backup), str(user_frontend_dir / "node_modules"))
-        
-        if 'dist_backup' in locals() and dist_backup and dist_backup.exists():
-            shutil.move(str(dist_backup), str(user_frontend_dir / "dist"))
-        
-        click.echo(f"✓ 前端代码已同步到: {user_frontend_dir}")
-    
-    # 工作目录切换到用户前端目录
-    frontend_dir = user_frontend_dir
-    
     # 检查 Node.js 是否安装
     node_cmd = shutil.which('node')
     if not node_cmd:
@@ -608,7 +545,7 @@ def frontend(port, host, auto_install, force_install, build_only):
     
     # 切换到前端目录
     os.chdir(frontend_dir)
-    click.echo(f"工作目录: {frontend_dir}")
+    click.echo(f"前端目录: {frontend_dir}")
     
     # 检查 package.json 是否存在
     package_json = frontend_dir / "package.json"
@@ -651,7 +588,8 @@ def frontend(port, host, auto_install, force_install, build_only):
     # 构建或启动
     try:
         # 构建生产版本
-        dist_dir = frontend_dir / "dist"
+        # 注意：根据 vite.config.js，构建输出到 ../static/dist
+        dist_dir = frontend_dir.parent / "static" / "dist"
         
         # 检查是否需要构建
         need_build = not dist_dir.exists() or build_only
@@ -681,35 +619,148 @@ def frontend(port, host, auto_install, force_install, build_only):
                 sys.exit(1)
             
             click.echo(f"\n正在启动生产版本服务器...")
-            click.echo(f"  - 地址: http://{host}:{port}")
-            click.echo(f"  - 本地访问: http://localhost:{port}")
-            click.echo(f"  - 静态文件目录: {dist_dir}")
+            click.echo(f"  - 访问地址: http://localhost:{port}")
+            if host != 'localhost':
+                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 Handler(http.server.SimpleHTTPRequestHandler):
+            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):
-                    # 对于 SPA 应用，所有路由都返回 index.html
-                    if self.path != '/' and not Path(dist_dir / self.path[1:]).exists():
-                        self.path = '/index.html'
+                    # 先尝试代理 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}")
             
             # 创建服务器
-            with socketserver.TCPServer((host, port), Handler) as httpd:
-                try:
-                    httpd.serve_forever()
-                except KeyboardInterrupt:
-                    pass
+            class ReuseAddrTCPServer(socketserver.TCPServer):
+                allow_reuse_address = True
+                allow_reuse_port = True
+            
+            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)

{jettask-0.2.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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.9 → jettask-0.2.13/jettask.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jettask
-Version: 0.2.9
+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.9 → jettask-0.2.13}/pyproject.toml

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