pindo 5.11.4 → 5.12.2

data/lib/pindo/module/task/task_manager.rb

@@ -1,23 +1,17 @@
 require 'singleton'
-require 'thread'
+require 'pindo/base/funlog'
 
 module Pindo
   module TaskSystem
+    # 简化版任务管理器
+    # 所有任务在主线程中按顺序执行
     class TaskManager
       include Singleton
 
       def initialize
         @pending_queue = []      # 待执行队列
-        @triggered_queue = []    # 已触发队列
-        @running_tasks = []      # 正在运行的任务
         @completed_tasks = []    # 已完成的任务
-        @task_locks = {
-          exclusive: Mutex.new,
-          type_locks: {}
-        }
-        @queue_mutex = Mutex.new
-        @queue_condition = ConditionVariable.new  # 用于等待/通知机制
-        @running = false
+        @current_task = nil      # 当前正在执行的任务
       end
 
       # 添加任务
@@ -34,13 +28,9 @@ module Pindo
           task.dependencies.concat(Array(options[:wait_for]))
         end
 
-        @queue_mutex.synchronize do
-          @pending_queue << task
-          # 按优先级排序
-          @pending_queue.sort_by! { |t| -t.priority }
-          # 通知等待的线程有新任务
-          @queue_condition.signal
-        end
+        @pending_queue << task
+        # 按优先级排序
+        @pending_queue.sort_by! { |t| -t.priority }
 
         task.id
       end
@@ -50,63 +40,60 @@ module Pindo
         tasks.map { |task| add_task(task) }
       end
 
-      # 开始执行（主线程循环）
+      # 开始执行（在主线程中顺序执行所有任务）
       def start
-        return if @running
-        @running = true
-
-        puts "\n[TaskManager] 开始执行任务调度...".cyan if defined?(String.cyan)
-
-        # 主线程循环：负责触发任务
-        while @running
-          task = nil
-
-          @queue_mutex.synchronize do
-            # 等待直到有可执行的任务或应该停止
-            while @running && !should_stop_locked?
-              task = get_next_executable_task_locked
-              if task
-                break
-              else
-                # 没有可执行的任务，等待通知
-                # 设置超时避免死锁，同时定期检查依赖状态
-                @queue_condition.wait(@queue_mutex, 1.0)
-
-                # 检查是否有因依赖失败需要级联处理的任务
-                check_and_cascade_failures_locked
-              end
+        # 输出任务执行计划
+        print_execution_plan
+
+        # 主循环：按顺序执行所有任务
+        while @pending_queue.any?
+          task = get_next_executable_task
+
+          unless task
+            # 检查是否所有任务都因依赖问题无法执行
+            if @pending_queue.all? { |t| check_dependencies(t) != :ready }
+              Funlog.warning("所有剩余任务都因依赖问题无法执行")
+              break
             end
 
-            # 如果应该停止且没有任务，退出循环
-            break if should_stop_locked? && task.nil?
-          end
-
-          # 在锁外触发任务
-          if task
-            trigger_task(task)
+            # 没有可执行的任务，短暂休眠后重试
+            sleep(0.1)
+            next
           end
 
-          # 清理已完成的异步任务
-          cleanup_finished_tasks
+          # 执行任务
+          execute_task(task)
         end
 
-        # 等待所有触发的任务完成
-        wait_all_triggered_tasks
-
-        puts "\n[TaskManager] 所有任务执行完毕".green if defined?(String.green)
-        @running = false
+        # 输出执行摘要
+        print_execution_summary
       end
 
-      # 停止执行
-      def stop
-        @running = false
+      # 获取执行报告
+      def execution_report
+        {
+          pending: @pending_queue.count,
+          completed: @completed_tasks.count,
+          success: @completed_tasks.count { |t| t.status == TaskStatus::SUCCESS },
+          failed: @completed_tasks.count { |t| t.status == TaskStatus::FAILED },
+          tasks: (@pending_queue + @completed_tasks).map do |task|
+            {
+              id: task.id,
+              name: task.name,
+              type: task.type,
+              status: task.status,
+              error: task.error&.message,
+              execution_time: task.execution_time
+            }
+          end
+        }
       end
 
-      # 等待所有任务完成
-      def wait_all
-        while @pending_queue.any? || @running_tasks.any?
-          sleep(0.1)
-        end
+      # 清空所有队列（用于重置）
+      def clear_all
+        @pending_queue.clear
+        @completed_tasks.clear
+        @current_task = nil
       end
 
       # 获取任务状态
@@ -121,120 +108,34 @@ module Pindo
         task&.cancel
       end
 
-      # 获取执行报告
-      def execution_report
-        @queue_mutex.synchronize do
-          {
-            pending: @pending_queue.count,
-            triggered: @triggered_queue.count,
-            running: @running_tasks.count,
-            completed: @completed_tasks.count,
-            success: @completed_tasks.count { |t| t.status == TaskStatus::SUCCESS },
-            failed: @completed_tasks.count { |t| t.status == TaskStatus::FAILED },
-            tasks: (@pending_queue + @triggered_queue + @running_tasks + @completed_tasks).map do |task|
-              {
-                id: task.id,
-                name: task.name,
-                type: task.type,
-                status: task.status,
-                execution_type: task.execution_type,
-                execution_mode: task.execution_mode,
-                error: task.error&.message,
-                progress: task.progress,
-                execution_time: task.execution_time
-              }
-            end
-          }
-        end
-      end
-
       private
 
-      # 获取下一个可执行的任务（需要在锁内调用）
-      def get_next_executable_task_locked
-        task = @pending_queue.find do |t|
-          can_execute?(t)
-        end
-
-        if task
-          @pending_queue.delete(task)
-          task
-        end
-      end
-
-      # 获取下一个可执行的任务（带锁版本，向后兼容）
+      # 获取下一个可执行的任务
       def get_next_executable_task
-        @queue_mutex.synchronize do
-          get_next_executable_task_locked
-        end
-      end
-
-      # 检查并级联处理失败的依赖（需要在锁内调用）
-      def check_and_cascade_failures_locked
-        @pending_queue.each do |task|
-          dependency_check = check_dependencies(task)
-          if dependency_check == :failed || dependency_check == :cancelled
-            cascade_failure_locked(task, dependency_check)
-          end
-        end
-      end
-
-      # 级联失败处理（锁内版本）
-      def cascade_failure_locked(task, reason)
-        case reason
-        when :failed
-          task.status = TaskStatus::FAILED
-          task.error = RuntimeError.new("依赖任务失败")
-          if defined?(String.red)
-            puts "[TaskManager] 任务 #{task.name} 因依赖失败而被标记为失败".red
-          else
-            puts "[TaskManager] 任务 #{task.name} 因依赖失败而被标记为失败"
-          end
-        when :cancelled
-          task.status = TaskStatus::CANCELLED
-          task.error = RuntimeError.new("依赖任务被取消")
-          if defined?(String.yellow)
-            puts "[TaskManager] 任务 #{task.name} 因依赖取消而被取消".yellow
-          else
-            puts "[TaskManager] 任务 #{task.name} 因依赖取消而被取消"
-          end
-        end
-
-        # 将任务移到完成队列
-        @pending_queue.delete(task)
-        @completed_tasks << task
-
-        # 通知可能有新的可执行任务
-        @queue_condition.signal
+        task = @pending_queue.find { |t| can_execute?(t) }
+        @pending_queue.delete(task) if task
+        task
       end
 
       # 判断任务是否可以执行
       def can_execute?(task)
-        # 1. 检查依赖状态
+        # 检查依赖状态
         dependency_check = check_dependencies(task)
 
-        # 如果依赖检查返回 :failed 或 :cancelled，级联处理
-        if dependency_check == :failed || dependency_check == :cancelled
-          cascade_failure(task, dependency_check)
+        if dependency_check == :failed
+          # 依赖失败，标记任务为失败
+          mark_task_failed(task, "依赖任务失败")
+          return false
+        elsif dependency_check == :cancelled
+          # 依赖被取消，标记任务为取消
+          mark_task_cancelled(task, "依赖任务被取消")
           return false
         elsif dependency_check == :waiting
           return false  # 依赖未完成，继续等待
         end
 
-        # 2. 根据执行模式检查并发限制
-        case task.execution_mode
-        when ExecutionMode::EXCLUSIVE
-          # 独占模式：没有其他任务在运行
-          @running_tasks.empty?
-        when ExecutionMode::TYPE_EXCLUSIVE
-          # 类型独占：没有相同类型的任务在运行
-          !@running_tasks.any? { |t| t.type == task.type }
-        when ExecutionMode::CONCURRENT
-          # 并发模式：可以执行
-          true
-        else
-          true
-        end
+        # 依赖已满足，可以执行
+        true
       end
 
       # 检查依赖状态
@@ -263,232 +164,181 @@ module Pindo
         :ready  # 所有依赖都成功完成
       end
 
-      # 级联失败处理
-      def cascade_failure(task, reason)
-        @queue_mutex.synchronize do
-          case reason
-          when :failed
-            task.status = TaskStatus::FAILED
-            task.error = RuntimeError.new("依赖任务失败")
-            if defined?(String.red)
-              puts "[TaskManager] 任务 #{task.name} 因依赖失败而被标记为失败".red
-            else
-              puts "[TaskManager] 任务 #{task.name} 因依赖失败而被标记为失败"
-            end
-          when :cancelled
-            task.status = TaskStatus::CANCELLED
-            task.error = RuntimeError.new("依赖任务被取消")
-            if defined?(String.yellow)
-              puts "[TaskManager] 任务 #{task.name} 因依赖取消而被取消".yellow
-            else
-              puts "[TaskManager] 任务 #{task.name} 因依赖取消而被取消"
-            end
-          end
+      # 执行任务
+      def execute_task(task)
+        @current_task = task
 
-          # 将任务移到完成队列
-          @pending_queue.delete(task)
-          @completed_tasks << task
-        end
-      end
-
-      # 触发任务执行
-      def trigger_task(task)
-        # 获取任务锁
-        lock_acquired = acquire_lock(task)
+        # 设置任务进度回调
+        setup_task_callbacks(task)
 
-        unless lock_acquired
-          # 无法获取锁，任务返回队列
-          @queue_mutex.synchronize do
-            @pending_queue.unshift(task)  # 放回队列前面
-            @queue_condition.signal
-          end
-          return
-        end
+        # 显示任务开始信息
+        print_task_header(task)
 
-        @queue_mutex.synchronize do
-          task.status = TaskStatus::TRIGGERED
-          @triggered_queue << task
-          @running_tasks << task
-        end
+        begin
+          # 在主线程中执行任务
+          task.do_task
 
-        # 显示触发信息
-        execution_type_str = task.execution_type == ExecutionType::SYNC ? "同步" : "异步"
-        if defined?(String.blue)
-          puts "\n[#{Time.now.strftime('%H:%M:%S')}] 触发任务: #{task.name} (#{execution_type_str})".blue
-        else
-          puts "\n[#{Time.now.strftime('%H:%M:%S')}] 触发任务: #{task.name} (#{execution_type_str})"
-        end
-        puts "  类型: #{task.type}, 模式: #{task.execution_mode}"
+          # 任务成功
+          print_task_success(task)
 
-        # 设置任务完成回调
-        task.on(:after) do |t|
-          on_task_finished(t)
+        rescue => e
+          # 任务失败
+          print_task_failure(task, e)
         end
 
-        # 设置进度回调
-        task.on(:on_progress) do |t|
-          if defined?(String.cyan)
-            puts "  [#{t.progress}%] #{t.progress_message}".cyan if t.progress_message
-          else
-            puts "  [#{t.progress}%] #{t.progress_message}" if t.progress_message
-          end
-        end
+        # 将任务移到完成队列
+        @completed_tasks << task
+        @current_task = nil
 
-        # 根据执行类型触发任务
-        case task.execution_type
-        when ExecutionType::SYNC
-          # 同步执行：在当前线程（主线程）执行
-          if defined?(String.yellow)
-            puts "  → 在主线程中同步执行".yellow
-          else
-            puts "  → 在主线程中同步执行"
-          end
-          task.do_task
-        when ExecutionType::ASYNC
-          # 异步执行：在新线程执行
-          if defined?(String.yellow)
-            puts "  → 在新线程中异步执行".yellow
-          else
-            puts "  → 在新线程中异步执行"
-          end
-          task.async_do_task
-        else
-          # 默认异步
-          task.async_do_task
-        end
+        # 任务完成后输出分隔线
+        print_task_footer
       end
 
-      # 任务完成回调
-      def on_task_finished(task)
-        @queue_mutex.synchronize do
-          @running_tasks.delete(task)
-          @triggered_queue.delete(task)
-          @completed_tasks << task
+      # 设置任务回调
+      def setup_task_callbacks(task)
+        # 只在第一次设置回调
+        return if task.callbacks_setup
 
-          # 释放任务锁
-          release_lock(task)
+        # 主线程执行不需要进度回调
 
-          # 通知等待的线程，可能有新的任务可以执行
-          @queue_condition.signal
-        end
+        task.callbacks_setup = true
+      end
 
-        # 显示完成信息
-        if task.status == TaskStatus::SUCCESS
-          time_str = task.execution_time ? " (#{task.execution_time.round(2)}s)" : ""
-          if defined?(String.green)
-            puts "[#{Time.now.strftime('%H:%M:%S')}] ✅ 完成: #{task.name}#{time_str}".green
-          else
-            puts "[#{Time.now.strftime('%H:%M:%S')}] ✅ 完成: #{task.name}#{time_str}"
-          end
-        elsif task.status == TaskStatus::FAILED
-          if defined?(String.red)
-            puts "[#{Time.now.strftime('%H:%M:%S')}] ❌ 失败: #{task.name}".red
-            puts "  错误: #{task.error.message}".red if task.error
-          else
-            puts "[#{Time.now.strftime('%H:%M:%S')}] ❌ 失败: #{task.name}"
-            puts "  错误: #{task.error.message}" if task.error
-          end
-        end
+      # 标记任务为失败
+      def mark_task_failed(task, reason)
+        @pending_queue.delete(task)
+        task.status = TaskStatus::FAILED
+        task.error = RuntimeError.new(reason)
+        @completed_tasks << task
+
+        Funlog.error("任务 #{task.name} 因#{reason}而被标记为失败")
       end
 
-      # 清理已完成的异步任务
-      def cleanup_finished_tasks
-        @queue_mutex.synchronize do
-          @running_tasks.select(&:finished?).each do |task|
-            # 任务已经通过回调处理，这里只是确保清理
-            unless @completed_tasks.include?(task)
-              on_task_finished(task)
-            end
-          end
-        end
+      # 标记任务为取消
+      def mark_task_cancelled(task, reason)
+        @pending_queue.delete(task)
+        task.status = TaskStatus::CANCELLED
+        task.error = RuntimeError.new(reason)
+        @completed_tasks << task
+
+        Funlog.warning("任务 #{task.name} 因#{reason}而被取消")
       end
 
-      # 判断是否应该停止（需要在锁内调用）
-      def should_stop_locked?
-        @pending_queue.empty? && @running_tasks.empty?
+      # 查找任务
+      def find_task(task_id)
+        all_tasks = @pending_queue + @completed_tasks
+        all_tasks << @current_task if @current_task
+        all_tasks.find { |t| t.id == task_id }
       end
 
-      # 判断是否应该停止（带锁版本）
-      def should_stop?
-        @queue_mutex.synchronize do
-          should_stop_locked?
+      # 输出任务执行计划
+      def print_execution_plan
+        # 按类型分组统计
+        tasks_by_type = @pending_queue.group_by(&:type)
+
+        puts "\n"
+        puts "\e[34m" + "=" * 60
+        puts "  任务执行计划"
+        puts "=" * 60
+
+        tasks_by_type.each do |type, tasks|
+          type_name = get_type_display_name(type)
+          puts "  #{type_name}: #{tasks.count} 个任务"
         end
+
+        puts "  总计: #{@pending_queue.count} 个任务"
+        puts "=" * 60 + "\e[0m"
+        puts "\n"
       end
 
-      # 等待所有已触发的任务完成
-      def wait_all_triggered_tasks
-        if defined?(String.yellow)
-          puts "\n等待所有异步任务完成...".yellow
+      # 获取任务类型的显示名称
+      def get_type_display_name(type)
+        case type
+        when :unity_export
+          "Unity 导出"
+        when :build
+          "编译构建"
+        when :upload
+          "上传发布"
         else
-          puts "\n等待所有异步任务完成..."
+          type.to_s.capitalize
         end
+      end
 
-        while true
-          @queue_mutex.synchronize do
-            break if @triggered_queue.empty? && @running_tasks.empty?
-          end
-          sleep(0.1)
-        end
+      # 输出任务执行头部
+      def print_task_header(task)
+        puts "\n"
+        puts "\e[34m" + "*" * 60
+        puts "  ▶ #{task.name}"
+        puts "*" * 60 + "\e[0m"
       end
 
-      # 查找任务
-      def find_task(task_id)
-        all_tasks = []
-        @queue_mutex.synchronize do
-          all_tasks = @pending_queue + @triggered_queue + @running_tasks + @completed_tasks
-        end
-        all_tasks.find { |t| t.id == task_id }
+      # 输出任务成功信息
+      def print_task_success(task)
+        time_str = task.execution_time ? task.execution_time.round(2) : 0
+        puts "\n"
+        puts "\e[34m" + "  ✓ 任务完成: #{task.name} (耗时: #{time_str}秒)" + "\e[0m"
       end
 
-      # 获取类型锁
-      def type_lock(type)
-        @task_locks[:type_locks][type] ||= Mutex.new
+      # 输出任务失败信息
+      def print_task_failure(task, error)
+        puts "\n"
+        Funlog.error("任务失败: #{task.name}")
+        Funlog.error("错误信息: #{error.message}")
       end
 
-      # 获取任务锁
-      def acquire_lock(task)
-        case task.execution_mode
-        when ExecutionMode::EXCLUSIVE
-          # 独占模式：尝试获取全局锁
-          @task_locks[:exclusive].try_lock
-        when ExecutionMode::TYPE_EXCLUSIVE
-          # 类型独占：尝试获取类型锁
-          type_lock(task.type).try_lock
-        when ExecutionMode::CONCURRENT
-          # 并发模式：不需要锁
-          true
-        else
-          true
-        end
+      # 输出任务底部分隔线
+      def print_task_footer
+        puts "\e[34m" + "*" * 60 + "\e[0m"
+        puts ""
       end
 
-      # 释放任务锁
-      def release_lock(task)
-        case task.execution_mode
-        when ExecutionMode::EXCLUSIVE
-          # 释放全局锁
-          @task_locks[:exclusive].unlock rescue nil
-        when ExecutionMode::TYPE_EXCLUSIVE
-          # 释放类型锁
-          type_lock(task.type).unlock rescue nil
+      # 输出执行摘要
+      def print_execution_summary
+        success_count = @completed_tasks.count { |t| t.status == TaskStatus::SUCCESS }
+        failed_count = @completed_tasks.count { |t| t.status == TaskStatus::FAILED }
+        cancelled_count = @completed_tasks.count { |t| t.status == TaskStatus::CANCELLED }
+
+        # 获取失败和取消的任务
+        failed_tasks = @completed_tasks.select { |t| t.status == TaskStatus::FAILED }
+        cancelled_tasks = @completed_tasks.select { |t| t.status == TaskStatus::CANCELLED }
+
+        # 计算总耗时
+        total_time = @completed_tasks.map(&:execution_time).compact.sum
+        minutes = (total_time / 60).to_i
+        seconds = (total_time % 60).to_i
+
+        puts "\n"
+        puts "\e[34m" + "=" * 60
+        puts "\e[34m" + "  任务执行完成"
+        puts "\e[34m" + "=" * 60
+
+        # 显示统计信息
+        puts "\e[34m" + "  成功: #{success_count} 个任务" + "\e[0m" if success_count > 0
+
+        if failed_count > 0
+          puts "\e[31m" + "  失败: #{failed_count} 个任务" + "\e[0m"
+          failed_tasks.each do |task|
+            puts "\e[31m" + "    - #{task.name}" + "\e[0m"
+          end
         end
-      end
 
-      # 清空所有队列（用于重置）
-      def clear_all
-        @queue_mutex.synchronize do
-          @pending_queue.clear
-          @triggered_queue.clear
-          @running_tasks.clear
-          @completed_tasks.clear
-
-          # 释放所有锁
-          @task_locks[:exclusive].unlock rescue nil
-          @task_locks[:type_locks].each_value do |lock|
-            lock.unlock rescue nil
+        if cancelled_count > 0
+          puts "\e[33m" + "  取消: #{cancelled_count} 个任务" + "\e[0m"
+          cancelled_tasks.each do |task|
+            puts "\e[33m" + "    - #{task.name}" + "\e[0m"
           end
         end
+
+        if minutes > 0
+          puts "\e[34m" + "  总耗时: #{minutes}分#{seconds}秒" + "\e[0m"
+        else
+          puts "\e[34m" + "  总耗时: #{seconds}秒" + "\e[0m"
+        end
+
+        puts "\e[34m" + "=" * 60 + "\e[0m"
+        puts "\n"
       end
     end
   end
-end
+end