pindo 5.13.12 → 5.13.13

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

@@ -5,6 +5,9 @@ module Pindo
     # 任务取消异常
     class TaskCancelledException < StandardError; end
 
+    # 资源锁超时异常
+    class ResourceLockTimeout < StandardError; end
+
     # 任务状态
     module TaskStatus
       PENDING = :pending       # 待执行
@@ -32,13 +35,47 @@ module Pindo
     # PindoTask 基类（简化版，所有任务在主线程中执行）
     class PindoTask
       attr_accessor :id, :name, :status, :error, :result
-      attr_reader :type, :task_key, :priority, :dependencies, :data_dependencies
+      attr_reader :type, :task_key, :priority, :dependencies
       attr_accessor :context, :metadata
       attr_reader :created_at, :started_at, :finished_at
       attr_accessor :retry_count  # 剩余重试次数
       attr_reader :retry_mode, :retry_delay, :max_retry_count  # max_retry_count: 初始最大重试次数
       attr_accessor :callbacks_setup  # 标记回调是否已经设置
       attr_accessor :task_manager  # TaskManager 实例（依赖注入）
+      attr_accessor :skip_count    # 因资源不足被跳过的次数
+
+      # 获取任务需要的资源（子类覆盖以声明所需资源）
+      # @return [Array<Hash>] 资源规格数组
+      #
+      # 资源规格格式：
+      #   { type: :xcode, directory: "/path/to/project" }  # 基于目录的资源
+      #   { type: :keychain }                              # 全局资源
+      #
+      # @example 基于目录的资源（相同目录互斥）
+      #   class IOSBuildTask < PindoTask
+      #     def initialize(name:, project_path:)
+      #       super(name)
+      #       @project_path = project_path
+      #     end
+      #
+      #     def required_resources
+      #       [
+      #         { type: :xcode, directory: @project_path },
+      #         { type: :git, directory: @project_path },
+      #         { type: :keychain }
+      #       ]
+      #     end
+      #   end
+      #
+      # @example 全局资源
+      #   class UploadTask < PindoTask
+      #     def required_resources
+      #       [{ type: :network }]
+      #     end
+      #   end
+      def required_resources
+        []  # 默认不需要资源
+      end
 
       def initialize(name, options = {})
         @id = SecureRandom.uuid
@@ -48,7 +85,6 @@ module Pindo
         @priority = options[:priority] || TaskPriority::HIGH
         @status = TaskStatus::PENDING
         @dependencies = options[:dependencies] || []
-        @data_dependencies = options[:data_dependencies] || []
         @context = options[:context] || {}
         @metadata = options[:metadata] || {}
         @error = nil
@@ -69,6 +105,7 @@ module Pindo
         @retry_count = options[:retry_count] || self.class.default_retry_count
         @max_retry_count = @retry_count  # 保存初始最大重试次数
         @retry_delay = options[:retry_delay] || self.class.default_retry_delay
+        @skip_count = 0  # 记录因资源不足被跳过的次数（用于解决饥饿问题）
       end
 
       # 子类必须实现的方法
@@ -196,17 +233,17 @@ module Pindo
         dep_task.data_param
       end
 
-      # 获取所有数据依赖任务的数据参数
+      # 获取所有依赖任务的数据参数
       # @return [Array<Hash>] 数据参数数组
       def get_all_data_params
-        @data_dependencies.map { |task_id| get_data_param(task_id) }.compact
+        @dependencies.map { |task_id| get_data_param(task_id) }.compact
       end
 
-      # 根据 task_key 获取数据依赖任务的数据参数
+      # 根据 task_key 获取依赖任务的数据参数
       # @param task_key [Symbol] 任务键
       # @return [Hash, nil] 第一个匹配的任务数据参数
       def get_data_param_by_key(task_key)
-        @data_dependencies.each do |task_id|
+        @dependencies.each do |task_id|
           param = get_data_param(task_id)
           return param if param && param[:task_key] == task_key
         end
@@ -220,11 +257,98 @@ module Pindo
         get_all_data_params.select { |param| param[:task_key] == task_key }
       end
 
-      # 获取主数据参数（第一个数据依赖任务的参数）
+      # 获取主数据参数（第一个依赖任务的参数）
       # @return [Hash, nil] 主数据参数
       def primary_data_param
-        return nil if @data_dependencies.empty?
-        get_data_param(@data_dependencies.first)
+        return nil if @dependencies.empty?
+        get_data_param(@dependencies.first)
+      end
+
+      # ========== 动态资源管理 ==========
+
+      # 临时锁定资源（块语法，推荐使用）
+      # 在代码块执行期间锁定资源，自动释放
+      #
+      # @param resource_spec [Hash, Array<Hash>] 资源规格
+      # @param timeout [Integer] 超时时间（秒）
+      # @yield 持有资源时执行的代码块
+      # @raise [ResourceLockTimeout] 如果无法获取资源
+      # @raise [RuntimeError] 如果任务未运行或未提供代码块
+      #
+      # @example 单个资源
+      #   with_resource({ type: :unity, directory: @path }) do
+      #     build_unity
+      #   end
+      #
+      # @example 多个资源
+      #   with_resources([
+      #     { type: :xcode, directory: @path },
+      #     { type: :keychain }
+      #   ]) do
+      #     sign_ipa
+      #   end
+      def with_resource(resource_spec, timeout: 30)
+        raise ArgumentError, "Block required" unless block_given?
+        raise RuntimeError, "Task not running (task_manager is nil)" unless @task_manager
+
+        resource_manager = @task_manager.resource_lock_manager
+        resource_specs = [resource_spec].flatten
+
+        # 阻塞式获取资源
+        success = resource_manager.acquire_blocking(resource_specs, @id, timeout: timeout)
+
+        unless success
+          raise ResourceLockTimeout, "无法获取资源: #{resource_specs.inspect}（超时#{timeout}秒）"
+        end
+
+        begin
+          yield  # 执行代码块
+        ensure
+          # 自动释放临时资源
+          resource_manager.release_partial(resource_specs, @id)
+        end
+      end
+
+      # 批量临时锁定资源（with_resource 的别名）
+      # @param resource_specs [Array<Hash>] 资源规格数组
+      # @param timeout [Integer] 超时时间（秒）
+      # @yield 持有资源时执行的代码块
+      def with_resources(resource_specs, timeout: 30, &block)
+        with_resource(resource_specs, timeout: timeout, &block)
+      end
+
+      # 提前释放资源
+      # 释放 required_resources 中声明的资源，允许其他任务使用
+      #
+      # @param resource_spec [Hash, Array<Hash>] 要释放的资源规格
+      # @raise [RuntimeError] 如果任务未运行
+      #
+      # @example 释放单个资源
+      #   def do_work
+      #     git_pull
+      #     release_resource({ type: :git, directory: @path })
+      #
+      #     xcode_build  # Git 已释放，其他任务可以使用
+      #   end
+      #
+      # @example 释放多个资源
+      #   release_resources([
+      #     { type: :git, directory: @path },
+      #     { type: :xcode, directory: @path }
+      #   ])
+      def release_resource(resource_spec)
+        raise RuntimeError, "Task not running (task_manager is nil)" unless @task_manager
+
+        resource_manager = @task_manager.resource_lock_manager
+        resource_specs = [resource_spec].flatten
+
+        resource_manager.release_partial(resource_specs, @id)
+      end
+
+      # 批量释放资源（release_resource 的别名）
+      # @param resource_specs [Array<Hash>] 资源规格数组
+      def release_resources(resource_specs)
+        release_resource(resource_specs)
       end
 
       # ========== 回调方法 ==========

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

@@ -1,82 +1,124 @@
 require 'singleton'
 require 'pindo/base/funlog'
+require_relative 'core/task_queue'
+require_relative 'core/dependency_checker'
+require_relative 'core/task_executor'
+require_relative 'core/execution_strategy'
+require_relative 'core/resource_lock_manager'
+require_relative 'task_reporter'
+require_relative 'output/multi_line_output_manager'
 
 module Pindo
   module TaskSystem
-    # 简化版任务管理器
-    # 所有任务在主线程中按顺序执行
+    # TaskManager - 任务管理器
+    #
+    # 职责：
+    # - 提供公共 API
+    # - 组合各个模块（队列、依赖检查、执行器、报告、资源锁）
+    # - 创建执行策略
     class TaskManager
       include Singleton
 
+      attr_reader :queue, :dependency_checker, :reporter, :resource_lock_manager
+
       def initialize
-        @pending_queue = []      # 待执行队列
-        @completed_tasks = []    # 已完成的任务
-        @current_task = nil      # 当前正在执行的任务
+        @queue = TaskQueue.new                               # 队列管理
+        @resource_lock_manager = ResourceLockManager.new     # 资源锁管理
+        @dependency_checker = DependencyChecker.new(@queue, @resource_lock_manager)  # 依赖检查
+        @reporter = TaskReporter.new(@queue)                 # 报告输出
+        @output_manager = nil                                 # 输出管理器
+      end
+
+      # ==================== 公共 API ====================
+
+      # 获取执行器（延迟初始化）
+      # @return [TaskExecutor] 任务执行器
+      def executor
+        @executor ||= TaskExecutor.new(@queue, @reporter, @resource_lock_manager, @output_manager)
+      end
+
+      # 启用输出管理系统
+      # @param options [Hash] 配置选项
+      def enable_output_management(options = {})
+        @output_manager = MultiLineOutputManager.new(
+          log_dir: options[:log_dir] || './pindo_logs',
+          max_lines_per_task: options[:max_lines_per_task] || 5,
+          max_recent_completed: options[:max_recent_completed] || 3,
+          auto_adjust: options.fetch(:auto_adjust, true)
+        )
+        # 更新执行器的输出管理器（如果已初始化）
+        @executor.output_manager = @output_manager if @executor
+      end
+
+      # 禁用输出管理系统
+      def disable_output_management
+        @output_manager = nil
+        @executor.output_manager = nil if @executor
       end
 
       # 添加任务
+      # @param task [PindoTask] 任务对象
+      # @param options [Hash] 选项
+      # @return [String] 任务 ID
       def add_task(task, options = {})
         raise ArgumentError, "Task must be a PindoTask" unless task.is_a?(PindoTask)
 
-        # 验证任务
         unless task.validate
           raise ArgumentError, "Task validation failed: #{task.name}"
         end
 
-        # 处理依赖
         if options[:wait_for]
           task.dependencies.concat(Array(options[:wait_for]))
         end
 
-        @pending_queue << task
-        # 按优先级排序
-        @pending_queue.sort_by! { |t| -t.priority }
-
-        task.id
+        @queue.add(task, sort_by_priority: true)
       end
 
       # 批量添加任务
+      # @param tasks [Array<PindoTask>] 任务数组
+      # @return [Array<String>] 任务 ID 数组
       def add_tasks(tasks)
         tasks.map { |task| add_task(task) }
       end
 
-      # 开始执行（在主线程中顺序执行所有任务）
-      def start
-        # 输出任务执行计划
-        print_execution_plan
-
-        # 主循环：按顺序执行所有任务
-        while @pending_queue.any?
-          task = get_next_executable_task
+      # 开始执行任务
+      # @param options [Hash] 执行选项
+      # @option options [Symbol] :mode 执行模式 (:serial, :concurrent)
+      # @option options [Boolean] :concurrent 快捷参数
+      # @option options [Integer] :max_workers 最大工作线程数
+      def start(options = {})
+        mode = parse_execution_mode(options)
+        strategy = ExecutionStrategy.create(mode, options)
 
-          unless task
-            # 检查是否所有任务都因依赖问题无法执行
-            if @pending_queue.all? { |t| check_dependencies(t) != :ready }
-              Funlog.warning("所有剩余任务都因依赖问题无法执行")
-              break
-            end
-
-            # 没有可执行的任务，短暂休眠后重试
-            sleep(0.1)
-            next
+        # 如果配置了输出管理器，注册所有任务
+        if @output_manager
+          @queue.pending_snapshot.each do |task|
+            @output_manager.register_task(task)
           end
-
-          # 执行任务
-          execute_task(task)
         end
 
+        # 输出任务执行计划
+        @reporter.print_execution_plan(strategy)
+
+        # 执行策略
+        strategy.execute(self)
+
         # 输出执行摘要
-        print_execution_summary
+        @reporter.print_execution_summary
       end
 
       # 获取执行报告
+      # @return [Hash] 执行报告
       def execution_report
+        pending = @queue.pending_snapshot
+        completed = @queue.completed_snapshot
+
         {
-          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|
+          pending: pending.count,
+          completed: completed.count,
+          success: completed.count { |t| t.status == TaskStatus::SUCCESS },
+          failed: completed.count { |t| t.status == TaskStatus::FAILED },
+          tasks: (pending + completed).map do |task|
             {
               id: task.id,
               name: task.name,
@@ -89,260 +131,48 @@ module Pindo
         }
       end
 
-      # 清空所有队列（用于重置）
+      # 清空所有队列
       def clear_all
-        @pending_queue.clear
-        @completed_tasks.clear
-        @current_task = nil
+        @queue.clear_all
       end
 
       # 获取任务状态
+      # @param task_id [String] 任务 ID
+      # @return [Symbol, nil] 任务状态
       def task_status(task_id)
         task = find_task(task_id)
         task&.status
       end
 
       # 取消任务
+      # @param task_id [String] 任务 ID
       def cancel_task(task_id)
         task = find_task(task_id)
         task&.cancel
       end
 
-      # 查找任务（公共方法，供 PindoTask 获取依赖任务使用）
+      # 查找任务
       # @param task_id [String] 任务 ID
       # @return [PindoTask, nil] 任务对象
       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 }
+        @queue.find(task_id)
       end
 
       private
 
-      # 获取下一个可执行的任务
-      def get_next_executable_task
-        task = @pending_queue.find { |t| can_execute?(t) }
-        @pending_queue.delete(task) if task
-        task
-      end
+      # ==================== 辅助方法（私有）====================
 
-      # 判断任务是否可以执行
-      def can_execute?(task)
-        # 检查依赖状态
-        dependency_check = check_dependencies(task)
-
-        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
-
-        # 依赖已满足，可以执行
-        true
-      end
-
-      # 检查依赖状态
-      def check_dependencies(task)
-        return :ready if task.dependencies.empty?
-
-        task.dependencies.each do |dep_id|
-          dep_task = find_task(dep_id)
-
-          # 依赖任务不存在
-          return :failed unless dep_task
-
-          # 检查依赖任务状态
-          case dep_task.status
-          when TaskStatus::SUCCESS
-            next  # 这个依赖已完成
-          when TaskStatus::FAILED
-            return :failed  # 依赖失败
-          when TaskStatus::CANCELLED
-            return :cancelled  # 依赖被取消
-          else
-            return :waiting  # 依赖未完成
-          end
-        end
-
-        :ready  # 所有依赖都成功完成
-      end
-
-      # 执行任务
-      def execute_task(task)
-        @current_task = task
-
-        # 注入 TaskManager 实例（依赖注入）
-        task.task_manager = self
-
-        # 设置任务进度回调
-        setup_task_callbacks(task)
-
-        # 显示任务开始信息
-        print_task_header(task)
-
-        begin
-          # 在主线程中执行任务
-          task.do_task
-
-          # 任务成功
-          print_task_success(task)
-
-        rescue => e
-          # 任务失败
-          print_task_failure(task, e)
-        end
-
-        # 将任务移到完成队列
-        @completed_tasks << task
-        @current_task = nil
-
-        # 任务完成后输出分隔线
-        print_task_footer
-      end
-
-      # 设置任务回调
-      def setup_task_callbacks(task)
-        # 只在第一次设置回调
-        return if task.callbacks_setup
-
-        # 主线程执行不需要进度回调
-
-        task.callbacks_setup = true
-      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 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 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 = tasks.first&.class&.task_type_name || type.to_s.capitalize
-          puts "\n  #{type_name}: #{tasks.count} 个任务"
-
-          # 显示该类型下的每个任务名称
-          tasks.each do |task|
-            puts "    - #{task.name}"
-          end
-        end
-
-        puts "\n  总计: #{@pending_queue.count} 个任务"
-        puts "=" * 60 + "\e[0m"
-        puts "\n"
-      end
-
-      # 输出任务执行头部
-      def print_task_header(task)
-        puts "\n"
-        puts "\e[34m" + "*" * 60
-        puts "  ▶ #{task.name}"
-        puts "*" * 60 + "\e[0m"
-      end
-
-      # 输出任务成功信息
-      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 print_task_failure(task, error)
-        puts "\n"
-        Funlog.error("任务失败: #{task.name}")
-        Funlog.error("错误信息: #{error.message}")
-
-        # 打印堆栈信息用于调试（仅在 PINDO_DEBUG 模式下）
-        if ENV['PINDO_DEBUG'] && error.backtrace && !error.backtrace.empty?
-          puts "\n堆栈信息:"
-          error.backtrace.first(10).each do |line|
-            puts "  #{line}"
-          end
-        end
-      end
-
-      # 输出任务底部分隔线
-      def print_task_footer
-        puts "\e[34m" + "*" * 60 + "\e[0m"
-        puts ""
-      end
-
-      # 输出执行摘要
-      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
-
-        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"
+      # 解析执行模式
+      # @param options [Hash] 选项
+      # @return [Symbol] 执行模式
+      def parse_execution_mode(options)
+        if options[:mode]
+          options[:mode]
+        elsif options.key?(:concurrent)
+          options[:concurrent] ? :concurrent : :serial
         else
-          puts "\e[34m" + "  总耗时: #{seconds}秒" + "\e[0m"
+          :serial  # 默认串行
         end
-
-        puts "\e[34m" + "=" * 60 + "\e[0m"
-        puts "\n"
       end
     end
   end