jettask 0.2.1__py3-none-any.whl → 0.2.4__py3-none-any.whl

jettask/core/cli.py

@@ -29,19 +29,75 @@ def cli():
 @cli.command()
 @click.option('--host', default='0.0.0.0', help='服务器监听地址')
 @click.option('--port', default=8001, type=int, help='服务器监听端口')
-def webui(host, port):
-    """启动 Web UI 监控界面"""
-    from jettask.webui.backend.main import run_server
-    click.echo(f"Starting JetTask Web UI on {host}:{port}")
+@click.option('--reload', is_flag=True, default=False, help='启用自动重载')
+@click.option('--log-level', default='info', 
+              type=click.Choice(['debug', 'info', 'warning', 'error']),
+              help='日志级别')
+@click.option('--unified', is_flag=True, default=False, help='使用统一的API路由器（实验性）')
+def api(host, port, reload, log_level, unified):
+    """启动 API 服务和监控界面
     
-    # 修改端口设置
+    示例:
+    \b
+      # 使用默认配置启动
+      jettask api
+      
+      # 指定端口和主机
+      jettask api --host 0.0.0.0 --port 8080
+      
+      # 启用开发模式（自动重载）
+      jettask api --reload --log-level debug
+      
+      # 使用旧版API（不推荐）
+      jettask api --no-unified
+    """
+    import os
     import uvicorn
-    uvicorn.run(
-        "jettask.webui.backend.main:app",
-        host=host,
-        port=port,
-        log_level="info"
-    )
+    
+    # 设置环境变量（如果需要）
+    if not os.getenv('JETTASK_PG_URL'):
+        os.environ['JETTASK_PG_URL'] = 'postgresql://jettask:123456@localhost:5432/jettask'
+    
+    if not os.getenv('JETTASK_CENTER_URL'):
+        os.environ['JETTASK_CENTER_URL'] = f'http://localhost:{port}/api/namespaces/default'
+    
+    # 选择使用的应用模块
+    if unified:
+        app_module = "jettask.webui.backend.main_unified:app"
+        click.echo(f"Starting JetTask API Server (Unified Mode - Experimental) on {host}:{port}")
+        click.echo("All API endpoints are consolidated in unified_api_router.py")
+        click.echo("NOTE: This mode requires specific database schema. Use --no-unified for production.")
+    else:
+        app_module = "jettask.webui.backend.main:app"
+        click.echo(f"Starting JetTask API Server on {host}:{port}")
+    
+    # 显示配置信息
+    click.echo("=" * 60)
+    click.echo("API Server Configuration")
+    click.echo("=" * 60)
+    click.echo(f"Host:        {host}")
+    click.echo(f"Port:        {port}")
+    click.echo(f"API Mode:    {'Unified' if unified else 'Legacy'}")
+    click.echo(f"Auto-reload: {reload}")
+    click.echo(f"Log level:   {log_level}")
+    click.echo(f"Database:    {os.getenv('JETTASK_PG_URL', 'Not configured')}")
+    click.echo("=" * 60)
+    
+    # 启动服务器
+    try:
+        uvicorn.run(
+            app_module,
+            host=host,
+            port=port,
+            log_level=log_level,
+            reload=reload
+        )
+    except KeyboardInterrupt:
+        click.echo("\nShutting down API Server...")
+    except Exception as e:
+        click.echo(f"Error starting API Server: {e}", err=True)
+        sys.exit(1)
+
 
 def load_module_from_path(module_path: str):
     """从文件路径加载 Python 模块"""
@@ -231,18 +287,51 @@ def worker(app_str, queues, executor, concurrency, prefetch, reload, config):
         sys.exit(1)
 
 @cli.command('webui-consumer')
-@click.option('--pg-url', help='PostgreSQL URL (optional, will use env var if not provided)')
-def webui_consumer(pg_url):
-    """启动 Web UI 数据消费者（同步 Redis 数据到 PostgreSQL）"""
-    click.echo("Starting WebUI Consumer...")
+@click.option('--task-center', '-tc', envvar='JETTASK_CENTER_URL', required=True,
+              help='任务中心URL，如: http://localhost:8001 或 http://localhost:8001/api/namespaces/default')
+@click.option('--check-interval', type=int, default=30,
+              help='命名空间检测间隔（秒），默认30秒')
+@click.option('--debug', is_flag=True, help='启用调试模式')
+def webui_consumer(task_center, check_interval, debug):
+    """启动数据消费者（自动识别单/多命名空间）
     
-    import os
-    if pg_url:
-        os.environ['JETTASK_PG_URL'] = pg_url
+    根据URL格式自动判断运行模式:
+    - 单命名空间: http://localhost:8001/api/namespaces/{name}
+    - 多命名空间: http://localhost:8001 或 http://localhost:8001/api
     
-    # 启动 pg_consumer (它会从环境变量读取 Redis 配置)
-    from jettask.webui.pg_consumer import main as consumer_main
-    consumer_main()
+    示例:
+    \b
+      # 为所有命名空间启动消费者（自动检测）
+      jettask webui-consumer --task-center http://localhost:8001
+      jettask webui-consumer --task-center http://localhost:8001/api
+      
+      # 为单个命名空间启动消费者
+      jettask webui-consumer --task-center http://localhost:8001/api/namespaces/default
+      
+      # 自定义检测间隔
+      jettask webui-consumer --task-center http://localhost:8001 --check-interval 60
+      
+      # 使用环境变量
+      export JETTASK_CENTER_URL=http://localhost:8001
+      jettask webui-consumer
+    """
+    import asyncio
+    from jettask.webui.unified_consumer_manager import UnifiedConsumerManager
+    
+    # 运行消费者管理器
+    async def run_manager():
+        """运行统一的消费者管理器"""
+        manager = UnifiedConsumerManager(
+            task_center_url=task_center,
+            check_interval=check_interval,
+            debug=debug
+        )
+        await manager.run()
+    
+    try:
+        asyncio.run(run_manager())
+    except KeyboardInterrupt:
+        click.echo("\nShutdown complete")
 
 @cli.command()
 def monitor():
@@ -252,16 +341,57 @@ def monitor():
     monitor_main()
 
 @cli.command()
-def init():
-    """初始化数据库和配置"""
+@click.option('--task-center', '-tc', envvar='JETTASK_CENTER_URL',
+              help='任务中心URL，如: http://localhost:8001/api/namespaces/default')
+def init(task_center):
+    """初始化数据库和配置
+    
+    示例:
+    \b
+      # 使用任务中心初始化
+      jettask init --task-center http://localhost:8001/api/namespaces/default
+      jettask init -tc http://localhost:8001/api/namespaces/production
+      
+      # 使用环境变量
+      export JETTASK_CENTER_URL=http://localhost:8001/api/namespaces/default
+      jettask init
+      
+      # 不使用任务中心（仅使用本地环境变量）
+      jettask init
+    """
     click.echo("Initializing JetTask...")
     
+    import os
+    
+    # 如果提供了任务中心URL，尝试从任务中心获取配置
+    if task_center:
+        os.environ['JETTASK_CENTER_URL'] = task_center
+        click.echo(f"Using Task Center: {task_center}")
+        
+        # 尝试从任务中心获取数据库配置
+        try:
+            from jettask.webui.task_center import TaskCenter
+            tc = TaskCenter(task_center)
+            if tc._connect_sync():
+                p_config = tc.pg_config
+                # 从任务中心获取的配置中提取数据库连接参数
+                os.environ['JETTASK_PG_HOST'] = p_config['host']
+                os.environ['JETTASK_PG_PORT'] = str(p_config['port'])
+                os.environ['JETTASK_PG_DATABASE'] = p_config['database']
+                os.environ['JETTASK_PG_USER'] = p_config['user']
+                os.environ['JETTASK_PG_PASSWORD'] = p_config['password']
+            else:
+                click.echo("⚠ Failed to connect to Task Center, using local configuration", err=True)
+        except Exception as e:
+            click.echo(f"⚠ Could not get configuration from Task Center: {e}", err=True)
+            click.echo("  Falling back to local environment variables")
+    
     # 初始化数据库
     from jettask.webui.db_init import init_database
-    click.echo("Initializing database...")
+    click.echo("\nInitializing database...")
     init_database()
     
-    click.echo("JetTask initialized successfully!")
+    click.echo("\n✓ JetTask initialized successfully!")
 
 @cli.command()
 def status():
@@ -296,179 +426,57 @@ def status():
     click.echo("=" * 50)
 
 @cli.command()
-@click.argument('app_str', required=False, default=None)
-@click.option('--interval', '-i', type=float, default=None, 
-              help='检查间隔（秒），默认使用app配置')
-@click.option('--batch-size', '-b', type=int, default=None,
-              help='每批处理的最大任务数，默认使用app配置')
-@click.option('--pg-url', '-p', envvar='JETTASK_PG_URL',
-              help='PostgreSQL 连接 URL（或设置 JETTASK_PG_URL 环境变量）')
-@click.option('--redis-url', '-r', envvar='REDIS_URL',
-              help='Redis 连接 URL（或设置 REDIS_URL 环境变量）')
+@click.option('--task-center', '-tc', envvar='JETTASK_CENTER_URL', required=True,
+              help='任务中心URL，如: http://localhost:8001 或 http://localhost:8001/api/namespaces/default')
+@click.option('--interval', '-i', type=float, default=0.1, 
+              help='调度器扫描间隔（秒），默认0.1秒')
+@click.option('--batch-size', '-b', type=int, default=100,
+              help='每批处理的最大任务数，默认100')
+@click.option('--check-interval', type=int, default=30,
+              help='命名空间检测间隔（秒），仅多命名空间模式使用，默认30秒')
 @click.option('--debug', is_flag=True, help='启用调试模式')
-def scheduler(app_str, interval, batch_size, pg_url, redis_url, debug):
-    """启动定时任务调度器
+def scheduler(task_center, interval, batch_size, check_interval, debug):
+    """启动定时任务调度器（自动识别单/多命名空间）
+    
+    根据URL格式自动判断运行模式:
+    - 单命名空间: http://localhost:8001/api/namespaces/{name}
+    - 多命名空间: http://localhost:8001 或 http://localhost:8001/api
     
     示例:
     \b
-      # 显式指定 app
-      jettask scheduler main:app
-      jettask scheduler tasks.py:app --interval 30
+      # 为所有命名空间启动调度器（自动检测）
+      jettask scheduler --task-center http://localhost:8001
+      jettask scheduler --task-center http://localhost:8001/api
       
-      # 自动发现 app
-      jettask scheduler
+      # 为单个命名空间启动调度器
+      jettask scheduler --task-center http://localhost:8001/api/namespaces/default
+      
+      # 自定义配置
+      jettask scheduler --task-center http://localhost:8001 --check-interval 60 --interval 0.5
       
       # 使用环境变量
-      export JETTASK_APP=myapp:app
-      export JETTASK_PG_URL=postgresql://user:pass@localhost/db
+      export JETTASK_CENTER_URL=http://localhost:8001
       jettask scheduler
     """
     import asyncio
+    from jettask.scheduler.unified_scheduler_manager import UnifiedSchedulerManager
+    
+    # 运行调度器管理器
+    async def run_manager():
+        """运行统一的调度器管理器"""
+        manager = UnifiedSchedulerManager(
+            task_center_url=task_center,
+            scan_interval=interval,
+            batch_size=batch_size,
+            check_interval=check_interval,
+            debug=debug
+        )
+        await manager.run()
     
-    # 处理相对导入
-    try:
-        from ..scheduler.scheduler import TaskScheduler
-        from ..scheduler.manager import ScheduledTaskManager
-    except ImportError:
-        # 直接运行时使用绝对导入
-        from jettask.scheduler.scheduler import TaskScheduler
-        from jettask.scheduler.manager import ScheduledTaskManager
-    
-    # 设置日志级别
-    if debug:
-        import logging
-        logging.basicConfig(level=logging.DEBUG)
-    
-    # 加载应用
-    try:
-        if app_str:
-            click.echo(f"Loading app from: {app_str}")
-            app = import_app(app_str)
-        else:
-            click.echo("Auto-discovering Jettask app...")
-            click.echo("Searching in: app.py, main.py, server.py, worker.py")
-            app = import_app()  # 自动发现
-        
-        # 显示应用信息
-        app_info = AppImporter.get_app_info(app)
-        click.echo(f"\nFound Jettask app:")
-        click.echo(f"  Tasks: {app_info['tasks']} registered")
-        if app_info.get('task_names') and app_info['tasks'] > 0:
-            task_preview = app_info['task_names'][:3]
-            click.echo(f"  Names: {', '.join(task_preview)}" + 
-                      (f" (+{app_info['tasks'] - 3} more)" if app_info['tasks'] > 3 else ""))
-    except ImportError as e:
-        click.echo(f"Error: {e}", err=True)
-        click.echo("\nTips:", err=True)
-        click.echo("  - Specify app location: jettask scheduler myapp:app", err=True)
-        click.echo("  - Or set environment variable: export JETTASK_APP=myapp:app", err=True)
-        click.echo("  - Or ensure app.py or main.py exists in current directory", err=True)
-        sys.exit(1)
-    except Exception as e:
-        import traceback
-        click.echo(f"Error loading app: {e}", err=True)
-        if debug:
-            traceback.print_exc()
-        sys.exit(1)
-    
-    # 获取配置
-    # 优先级：命令行参数 > 环境变量 > app 配置
-    redis_url = redis_url or getattr(app, 'redis_url', 'redis://localhost:6379/0')
-    pg_url = pg_url or getattr(app, 'pg_url', None)
-    
-    # 从app的scheduler_config获取默认值
-    scheduler_config = getattr(app, 'scheduler_config', {})
-    if interval is None:
-        interval = scheduler_config.get('scan_interval', 0.1)
-    if batch_size is None:
-        batch_size = scheduler_config.get('batch_size', 100)
-    
-    # 显示配置信息
-    click.echo("\n" + "=" * 60)
-    click.echo("JetTask Scheduler Configuration")
-    click.echo("=" * 60)
-    click.echo(f"App:          {app_str or 'auto-discovered'}")
-    click.echo(f"Redis URL:    {redis_url}")
-    click.echo(f"PostgreSQL:   {pg_url or 'Not configured'}")
-    if pg_url and not (pg_url.startswith('postgresql://') or pg_url.startswith('postgres://')):
-        click.echo(f"  Source:     From app configuration")
-    click.echo(f"Interval:     {interval} seconds (from {'CLI' if '--interval' in sys.argv else 'app config'})")
-    click.echo(f"Batch Size:   {batch_size} (from {'CLI' if '--batch-size' in sys.argv else 'app config'})")
-    click.echo(f"Debug:        {'Enabled' if debug else 'Disabled'}")
-    click.echo("=" * 60)
-    
-    # 检查 PostgreSQL 配置
-    if not pg_url:
-        click.echo("\n" + "=" * 60)
-        click.echo("ERROR: PostgreSQL configuration is required for scheduler")
-        click.echo("=" * 60)
-        click.echo("\nThe scheduler requires PostgreSQL to:")
-        click.echo("  • Store scheduled task definitions")
-        click.echo("  • Track task execution history")
-        click.echo("  • Manage cron schedules")
-        click.echo("\nPlease configure PostgreSQL using one of these methods:")
-        click.echo("\n1. Command line option:")
-        click.echo("   jettask scheduler --pg-url postgresql://user:pass@localhost/db")
-        click.echo("\n2. Environment variable:")
-        click.echo("   export JETTASK_PG_URL=postgresql://user:pass@localhost/db")
-        click.echo("   jettask scheduler")
-        click.echo("\n3. Example with local PostgreSQL:")
-        click.echo("   jettask scheduler --pg-url postgresql://jettask:123456@localhost/jettask")
-        click.echo("=" * 60)
-        sys.exit(1)
-    
-    # 创建调度器实例
-    click.echo("\nUsing PostgreSQL for scheduled task management")
-    manager = ScheduledTaskManager(pg_url)
-    scheduler_instance = TaskScheduler(
-        app=app,
-        redis_url=redis_url,
-        db_manager=manager,
-        scan_interval=interval,
-        batch_size=batch_size
-    )
-    
-    # 运行调度器
-    async def run_scheduler():
-        """运行调度器的异步函数"""
-        try:
-            click.echo("\nStarting scheduler...")
-            # 先连接
-            await scheduler_instance.connect()
-            # 然后运行
-            await scheduler_instance.run()
-        except KeyboardInterrupt:
-            click.echo("\nReceived shutdown signal, stopping scheduler...")
-        except Exception as e:
-            click.echo(f"\nScheduler error: {e}", err=True)
-            if debug:
-                import traceback
-                traceback.print_exc()
-        finally:
-            # 停止调度器
-            scheduler_instance.stop()
-            
-            # 强制清理leader锁
-            if scheduler_instance.is_leader and scheduler_instance.redis:
-                try:
-                    leader_key = f"{scheduler_instance.redis_prefix}:leader"
-                    await scheduler_instance.redis.delete(leader_key)
-                    click.echo("Leader lock cleaned up")
-                except Exception as e:
-                    click.echo(f"Failed to cleanup leader lock: {e}", err=True)
-            
-            # 确保断开连接
-            await scheduler_instance.disconnect()
-            click.echo("Scheduler stopped")
-    
-    # 启动事件循环
     try:
-        asyncio.run(run_scheduler())
+        asyncio.run(run_manager())
     except KeyboardInterrupt:
-        click.echo("\nScheduler shutdown complete")
-    except Exception as e:
-        click.echo(f"Fatal error: {e}", err=True)
-        sys.exit(1)
+        click.echo("\nShutdown complete")
 
 def main():
     """主入口函数"""