pindo 5.13.12 → 5.13.13

data/lib/pindo/module/task/core/concurrent_execution_strategy.rb

@@ -0,0 +1,237 @@
+require 'pindo/base/funlog'
+require 'thread'
+require_relative 'execution_strategy'
+
+module Pindo
+  module TaskSystem
+    # ConcurrentExecutionStrategy - 并发执行策略
+    #
+    # 职责：
+    # - 在多线程中并发执行独立任务
+    # - 控制最大工作线程数
+    # - 处理线程安全和任务同步
+    class ConcurrentExecutionStrategy < ExecutionStrategy
+      # 初始化
+      # @param max_workers [Integer] 最大工作线程数
+      def initialize(max_workers: 4)
+        @max_workers = max_workers
+        @mutex = Mutex.new
+        @running_tasks = []  # 正在运行的任务
+        @threads = []        # 工作线程
+        @threads = []        # 工作线程
+        @completion_queue = Queue.new  # 任务完成通知队列
+      end
+
+      # 饥饿阈值：任务被跳过多少次后进入饥饿模式
+      STARVATION_THRESHOLD = 5
+
+      # 执行任务
+      # @param task_manager [TaskManager] 任务管理器
+      def execute(task_manager)
+        queue = task_manager.queue
+        checker = task_manager.dependency_checker
+        executor = task_manager.executor
+
+        loop do
+          # 启动新任务（直到达到 max_workers 上限）
+          start_pending_tasks(queue, checker, executor, task_manager)
+
+          # 退出条件：无正在运行的任务 + 待执行队列为空
+          if no_running_tasks? && queue.pending_empty?
+            Funlog.info("[并发策略] 退出循环：无运行任务且队列为空")
+            break
+          end
+
+          # 如果所有任务都因依赖问题阻塞，且没有正在运行的任务
+          if no_running_tasks? && checker.all_pending_blocked?
+            pending_count = queue.pending_snapshot.size
+            Funlog.warning("[并发策略] 所有剩余任务都因依赖问题无法执行 (待执行: #{pending_count})")
+            # 打印所有待执行任务的状态
+            queue.pending_snapshot.each do |task|
+              dep_status = checker.check_dependencies(task)
+              Funlog.warning("  - 任务: #{task.name}, 依赖检查结果: #{dep_status}")
+            end
+            break
+          end
+
+          # 等待至少一个任务完成
+          wait_for_task_completion if has_running_tasks?
+        end
+
+        # 等待所有线程完成
+        @threads.each(&:join)
+      end
+
+      # 策略名称
+      # @return [String]
+      def name
+        "并发执行 (#{@max_workers} 线程)"
+      end
+
+      private
+
+      # 启动待执行任务
+      # @param queue [TaskQueue] 任务队列
+      # @param checker [DependencyChecker] 依赖检查器
+      # @param executor [TaskExecutor] 任务执行器
+      # @param task_manager [TaskManager] 任务管理器
+      # 启动待执行任务
+      # @param queue [TaskQueue] 任务队列
+      # @param checker [DependencyChecker] 依赖检查器
+      # @param executor [TaskExecutor] 任务执行器
+      # @param task_manager [TaskManager] 任务管理器
+      def start_pending_tasks(queue, checker, executor, task_manager)
+        resource_manager = task_manager.resource_lock_manager
+
+        while can_start_more_tasks?
+          # 先检查依赖（不在锁内）
+          pending_tasks = queue.pending_snapshot
+          if ENV['PINDO_DEBUG']
+            Funlog.info("[并发策略] 待执行任务数: #{pending_tasks.size}, 正在运行: #{@running_tasks.size}/#{@max_workers}")
+          end
+
+          executable_tasks = pending_tasks.select { |t| checker.dependencies_satisfied?(t) }
+          if ENV['PINDO_DEBUG']
+            Funlog.info("[并发策略] 依赖满足的任务数: #{executable_tasks.size}")
+          end
+
+          if executable_tasks.empty?
+            if ENV['PINDO_DEBUG']
+              Funlog.info("[并发策略] 没有可执行的任务，退出启动循环")
+            end
+            break
+          end
+
+          # 尝试获取第一个可用的任务（原子操作）
+          task = nil
+          starvation_mode = false
+
+          executable_tasks.each do |candidate|
+            # 调试：打印任务资源信息
+            if ENV['PINDO_DEBUG']
+              resources = candidate.required_resources
+              Funlog.info("[并发策略] 检查任务 #{candidate.name} 的资源: #{resources.inspect}")
+            end
+
+            # 检查资源是否可用
+            if resource_manager.available?(candidate.required_resources)
+              if ENV['PINDO_DEBUG']
+                Funlog.info("[并发策略] 资源可用，尝试获取任务: #{candidate.name}")
+              end
+
+              # 尝试获取任务和资源
+              task = queue.find_and_remove do |t|
+                t.id == candidate.id &&
+                  resource_manager.try_acquire(t.required_resources, t.id)
+              end
+
+              if task
+                if ENV['PINDO_DEBUG']
+                  Funlog.info("[并发策略] ✓ 成功获取任务: #{task.name}")
+                  Funlog.info("[并发策略] 当前锁定资源: #{resource_manager.lock_status.inspect}")
+                end
+                # 成功获取资源，重置跳过计数
+                task.skip_count = 0
+                break
+              end
+            else
+              # 资源不可用，增加跳过计数
+              candidate.skip_count += 1
+              if ENV['PINDO_DEBUG']
+                Funlog.info("[并发策略] 任务 #{candidate.name} 资源不足 (跳过次数: #{candidate.skip_count})")
+              end
+
+              # 检查是否达到饥饿阈值
+              if candidate.skip_count >= STARVATION_THRESHOLD
+                Funlog.warning("[并发策略] 任务 #{candidate.name} 进入饥饿模式 (跳过 #{candidate.skip_count} 次)")
+                Funlog.warning("  -> 暂停调度新任务，直到该任务能够执行")
+                starvation_mode = true
+                break # 立即停止调度其他任务
+              end
+            end
+          end
+
+          # 如果进入饥饿模式，直接退出循环，不再调度任何新任务
+          if starvation_mode
+            break
+          end
+
+          unless task
+            if ENV['PINDO_DEBUG']
+              Funlog.warning("[并发策略] 无法获取任务（可能资源被占用）")
+            end
+            break
+          end
+
+          start_task_in_thread(task, executor, task_manager)
+        end
+      end
+
+      # 在线程中启动任务
+      # @param task [PindoTask] 任务对象
+      # @param executor [TaskExecutor] 任务执行器
+      # @param task_manager [TaskManager] 任务管理器
+      def start_task_in_thread(task, executor, task_manager)
+        # 将任务添加到队列的运行队列（用于依赖检查）
+        task_manager.queue.add_running(task)
+
+        thread = Thread.new do
+          begin
+            executor.execute_task_sync(task, task_manager)
+            if ENV['PINDO_DEBUG']
+              Funlog.info("[并发策略] 任务完成: #{task.name}, 状态: #{task.status}")
+            end
+          ensure
+            cleanup_task(task, task_manager)
+          end
+        end
+
+        @mutex.synchronize do
+          @running_tasks << task
+          @threads << thread
+        end
+      end
+
+      # 清理任务
+      # @param task [PindoTask] 任务对象
+      # @param task_manager [TaskManager] 任务管理器
+      def cleanup_task(task, task_manager)
+        # 从队列的运行队列中移除
+        task_manager.queue.remove_running(task)
+
+        @mutex.synchronize do
+          @running_tasks.delete(task)
+          @threads.delete(Thread.current)
+        end
+
+        # 通知主循环任务已完成（非阻塞）
+        @completion_queue.push(task)
+      end
+
+      # 是否可以启动更多任务
+      # @return [Boolean]
+      def can_start_more_tasks?
+        @mutex.synchronize { @running_tasks.size < @max_workers }
+      end
+
+      # 是否有正在运行的任务
+      # @return [Boolean]
+      def has_running_tasks?
+        @mutex.synchronize { !@running_tasks.empty? }
+      end
+
+      # 是否没有正在运行的任务
+      # @return [Boolean]
+      def no_running_tasks?
+        @mutex.synchronize { @running_tasks.empty? }
+      end
+
+      # 等待任意一个任务完成
+      # 使用 Queue.pop 阻塞等待，而不是等待特定线程
+      # 这样即使第一个任务很慢，后续快速任务完成后也能立即启动新任务
+      def wait_for_task_completion
+        @completion_queue.pop  # 阻塞等待任意一个任务完成
+      end
+    end
+  end
+end

data/lib/pindo/module/task/core/dependency_checker.rb

@@ -0,0 +1,123 @@
+require 'pindo/base/funlog'
+
+module Pindo
+  module TaskSystem
+    # DependencyChecker - 依赖检查器
+    #
+    # 职责：
+    # - 检查任务是否可以执行
+    # - 检查依赖状态
+    # - 检查资源可用性
+    # - 标记任务失败或取消
+    class DependencyChecker
+      def initialize(queue, resource_lock_manager)
+        @queue = queue
+        @resource_lock_manager = resource_lock_manager
+      end
+
+      # 判断任务依赖是否满足（不检查资源）
+      # @param task [PindoTask] 任务对象
+      # @return [Boolean]
+      def dependencies_satisfied?(task)
+        # 检查依赖状态
+        dependency_check = check_dependencies(task)
+
+        case dependency_check
+        when :failed
+          mark_task_failed(task, "依赖任务失败")
+          false
+        when :cancelled
+          mark_task_cancelled(task, "依赖任务被取消")
+          false
+        when :waiting
+          false  # 依赖未完成，继续等待
+        else
+          true  # 依赖已满足
+        end
+      end
+
+      # 判断任务是否可以执行（检查依赖和资源）
+      # @param task [PindoTask] 任务对象
+      # @return [Boolean]
+      def can_execute?(task)
+        dependencies_satisfied?(task) && check_resources_available?(task)
+      end
+
+      # 检查资源是否可用
+      # @param task [PindoTask] 任务对象
+      # @return [Boolean]
+      def check_resources_available?(task)
+        resource_names = task.required_resources
+        return true if resource_names.nil? || resource_names.empty?
+
+        @resource_lock_manager.available?(resource_names)
+      end
+
+      # 检查依赖状态
+      # @param task [PindoTask] 任务对象
+      # @return [Symbol] :ready, :waiting, :failed, :cancelled
+      def check_dependencies(task)
+        return :ready if task.dependencies.empty?
+
+        task.dependencies.each do |dep_id|
+          dep_task = @queue.find(dep_id)
+
+          # 依赖任务不存在
+          unless dep_task
+            Funlog.error("[依赖检查] 任务 #{task.name}: 依赖任务 #{dep_id} 不存在")
+            return :failed
+          end
+
+          # 检查依赖任务状态
+          case dep_task.status
+          when TaskStatus::SUCCESS
+            next  # 这个依赖已完成
+          when TaskStatus::FAILED
+            Funlog.error("[依赖检查] 任务 #{task.name}: 依赖任务 #{dep_task.name} 失败 (状态: #{dep_task.status})")
+            return :failed  # 依赖失败
+          when TaskStatus::CANCELLED
+            Funlog.warning("[依赖检查] 任务 #{task.name}: 依赖任务 #{dep_task.name} 被取消 (状态: #{dep_task.status})")
+            return :cancelled  # 依赖被取消
+          else
+            # Funlog.info("[依赖检查] 任务 #{task.name}: 依赖任务 #{dep_task.name} 未完成 (状态: #{dep_task.status})")
+            return :waiting  # 依赖未完成
+          end
+        end
+
+        :ready  # 所有依赖都成功完成
+      end
+
+      # 检查是否所有待执行任务都因依赖问题无法执行
+      # @return [Boolean]
+      def all_pending_blocked?
+        @queue.all_pending? { |t| check_dependencies(t) != :ready }
+      end
+
+      private
+
+      # 标记任务为失败
+      # @param task [PindoTask] 任务对象
+      # @param reason [String] 失败原因
+      def mark_task_failed(task, reason)
+        @queue.remove_pending(task)
+        task.status = TaskStatus::FAILED
+        task.error = RuntimeError.new(reason)
+        @queue.mark_completed(task)
+
+        Funlog.error("任务 #{task.name} 因#{reason}而被标记为失败")
+      end
+
+      # 标记任务为取消
+      # @param task [PindoTask] 任务对象
+      # @param reason [String] 取消原因
+      def mark_task_cancelled(task, reason)
+        @queue.remove_pending(task)
+        task.status = TaskStatus::CANCELLED
+        task.error = RuntimeError.new(reason)
+        @queue.mark_completed(task)
+
+        Funlog.warning("任务 #{task.name} 因#{reason}而被取消")
+      end
+    end
+  end
+end

data/lib/pindo/module/task/core/execution_strategy.rb

@@ -0,0 +1,61 @@
+module Pindo
+  module TaskSystem
+    # ExecutionStrategy - 执行策略基类
+    #
+    # 定义所有执行策略必须实现的接口
+    # 遵循策略模式（Strategy Pattern）
+    #
+    # 职责：
+    # - 定义统一的策略接口
+    # - 强制子类实现核心方法
+    # - 提供策略工厂方法
+    # - 支持里氏替换原则（LSP）
+    class ExecutionStrategy
+      # 执行任务（抽象方法，子类必须实现）
+      # @param task_manager [TaskManager] 任务管理器
+      # @raise [NotImplementedError] 如果子类未实现此方法
+      def execute(task_manager)
+        raise NotImplementedError, "#{self.class} must implement #execute"
+      end
+
+      # 策略名称（抽象方法，子类必须实现）
+      # @return [String] 策略的显示名称
+      # @raise [NotImplementedError] 如果子类未实现此方法
+      def name
+        raise NotImplementedError, "#{self.class} must implement #name"
+      end
+
+      # ==================== 策略工厂（类方法）====================
+
+      # 创建执行策略
+      # @param mode [Symbol] 执行模式 (:serial, :concurrent)
+      # @param options [Hash] 选项
+      # @option options [Integer] :max_workers 最大工作线程数（并发模式）
+      # @return [ExecutionStrategy] 策略对象
+      def self.create(mode, options = {})
+        case mode
+        when :serial
+          SerialExecutionStrategy.new
+        when :concurrent
+          max_workers = options[:max_workers] || detect_optimal_workers
+          ConcurrentExecutionStrategy.new(max_workers: max_workers)
+        else
+          raise ArgumentError, "Unknown execution mode: #{mode}"
+        end
+      end
+
+      # 检测最优工作线程数
+      # @return [Integer] 工作线程数
+      def self.detect_optimal_workers
+        require 'etc'
+        [Etc.nprocessors, 2].max
+      rescue
+        4
+      end
+    end
+  end
+end
+
+# 加载具体的执行策略实现
+require_relative 'serial_execution_strategy'
+require_relative 'concurrent_execution_strategy'

data/lib/pindo/module/task/core/resource_lock_manager.rb

@@ -0,0 +1,190 @@
+require_relative '../task_resources/resource_registry'
+require_relative '../task_resources/resource_instance'
+
+module Pindo
+  module TaskSystem
+    # 资源锁管理器 v3.0 - 支持基于上下文的资源锁定
+    #
+    # 功能：
+    # 1. 支持基于目录的资源（相同目录互斥，不同目录可并行）
+    # 2. 支持全局互斥资源（永远互斥）
+    # 3. 支持全局共享资源（永不冲突）
+    # 4. 原子性获取 - 要么全部获取，要么全部失败
+    # 5. 线程安全 - 使用 Mutex 保护
+    # 6. 支持阻塞式获取（带超时）
+    # 7. 支持部分释放资源
+    #
+    # 资源规格格式：
+    #   { type: :xcode, directory: "/path/to/project" }
+    #   { type: :keychain }
+    #   { type: :network }
+    class ResourceLockManager
+      # 资源锁超时异常
+      class ResourceLockTimeout < StandardError; end
+
+      def initialize
+        @mutex = Mutex.new
+        @locked_resources = []  # [{ instance: ResourceInstance, task_id: String }]
+        @registry = TaskResources::ResourceRegistry.new
+      end
+
+      # 尝试获取资源锁（非阻塞）
+      # @param resource_specs [Array<Hash>] 资源规格数组
+      # @param task_id [String] 任务ID
+      # @return [Boolean] 是否成功获取所有资源
+      def try_acquire(resource_specs, task_id)
+        return true if resource_specs.nil? || resource_specs.empty?
+
+        instances = parse_resource_specs(resource_specs)
+
+        @mutex.synchronize do
+          return false if has_conflicts?(instances)
+
+          # 锁定所有资源
+          instances.each do |instance|
+            @locked_resources << { instance: instance, task_id: task_id }
+          end
+
+          true
+        end
+      end
+
+      # 阻塞式获取资源锁（带超时）
+      # @param resource_specs [Array<Hash>] 资源规格数组
+      # @param task_id [String] 任务ID
+      # @param timeout [Integer] 超时时间（秒）
+      # @return [Boolean] 是否成功获取
+      def acquire_blocking(resource_specs, task_id, timeout: 30)
+        return true if resource_specs.nil? || resource_specs.empty?
+
+        deadline = Time.now + timeout
+
+        loop do
+          return true if try_acquire(resource_specs, task_id)
+
+          if Time.now >= deadline
+            return false  # 超时
+          end
+
+          sleep(0.1)  # 短暂等待后重试
+        end
+      end
+
+      # 释放任务占用的所有资源
+      # @param task_id [String] 任务ID
+      def release(task_id)
+        @mutex.synchronize do
+          @locked_resources.delete_if { |lock| lock[:task_id] == task_id }
+        end
+      end
+
+      # 释放任务占用的部分资源
+      # @param resource_specs [Array<Hash>] 要释放的资源规格
+      # @param task_id [String] 任务ID
+      def release_partial(resource_specs, task_id)
+        return if resource_specs.nil? || resource_specs.empty?
+
+        instances = parse_resource_specs(resource_specs)
+
+        @mutex.synchronize do
+          instances.each do |instance|
+            @locked_resources.delete_if do |lock|
+              lock[:task_id] == task_id && lock[:instance].matches?(instance)
+            end
+          end
+        end
+      end
+
+      # 检查资源是否可用
+      # @param resource_specs [Array<Hash>] 资源规格数组
+      # @return [Boolean]
+      def available?(resource_specs)
+        return true if resource_specs.nil? || resource_specs.empty?
+
+        instances = parse_resource_specs(resource_specs)
+
+        @mutex.synchronize do
+          !has_conflicts?(instances)
+        end
+      end
+
+      # 获取资源锁定状态（用于调试和监控）
+      # @return [Hash] 资源锁定状态信息
+      def lock_status
+        @mutex.synchronize do
+          {
+            total_locks: @locked_resources.size,
+            locks_by_task: group_locks_by_task,
+            locks_by_resource: group_locks_by_resource
+          }
+        end
+      end
+
+      # 获取任务占用的资源列表
+      # @param task_id [String] 任务ID
+      # @return [Array<ResourceInstance>] 资源实例列表
+      def locked_resources(task_id)
+        @mutex.synchronize do
+          @locked_resources
+            .select { |lock| lock[:task_id] == task_id }
+            .map { |lock| lock[:instance] }
+        end
+      end
+
+      private
+
+      # 解析资源规格为资源实例
+      # @param specs [Array<Hash>] 资源规格数组
+      # @return [Array<ResourceInstance>]
+      def parse_resource_specs(specs)
+        specs = [specs] unless specs.is_a?(Array)
+
+        specs.map do |spec|
+          unless spec.is_a?(Hash) && spec[:type]
+            raise ArgumentError, "Invalid resource spec: #{spec.inspect}"
+          end
+
+          type_obj = @registry.get(spec[:type])
+          context = spec.reject { |k, _| k == :type }  # 除了 :type 之外的都是上下文
+          TaskResources::ResourceInstance.new(type_obj, context)
+        end
+      end
+
+      # 检查是否有冲突
+      # @param new_instances [Array<ResourceInstance>]
+      # @return [Boolean]
+      def has_conflicts?(new_instances)
+        new_instances.any? do |new_inst|
+          @locked_resources.any? do |lock|
+            new_inst.conflicts_with?(lock[:instance])
+          end
+        end
+      end
+
+      # 按任务分组锁定信息
+      # @return [Hash] { task_id => [resource_instance, ...] }
+      def group_locks_by_task
+        result = Hash.new { |h, k| h[k] = [] }
+
+        @locked_resources.each do |lock|
+          result[lock[:task_id]] << lock[:instance].to_s
+        end
+
+        result
+      end
+
+      # 按资源类型分组锁定信息
+      # @return [Hash] { resource_name => [task_id, ...] }
+      def group_locks_by_resource
+        result = Hash.new { |h, k| h[k] = [] }
+
+        @locked_resources.each do |lock|
+          resource_name = lock[:instance].type.name
+          result[resource_name] << lock[:task_id]
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/pindo/module/task/core/serial_execution_strategy.rb

@@ -0,0 +1,60 @@
+require 'pindo/base/funlog'
+require_relative 'execution_strategy'
+
+module Pindo
+  module TaskSystem
+    # SerialExecutionStrategy - 串行执行策略
+    #
+    # 职责：
+    # - 在主线程中按顺序执行所有任务
+    # - 处理依赖关系和阻塞情况
+    class SerialExecutionStrategy < ExecutionStrategy
+      # 执行任务
+      # @param task_manager [TaskManager] 任务管理器
+      def execute(task_manager)
+        queue = task_manager.queue
+        checker = task_manager.dependency_checker
+        executor = task_manager.executor
+        resource_manager = task_manager.resource_lock_manager
+
+        # 主循环：按顺序执行所有任务
+        while !queue.pending_empty?
+          # 先检查依赖（不在锁内）
+          pending_tasks = queue.pending_snapshot
+          executable_task = pending_tasks.find { |t| checker.dependencies_satisfied?(t) }
+
+          unless executable_task
+            # 检查是否所有任务都因依赖问题无法执行
+            if checker.all_pending_blocked?
+              Funlog.warning("所有剩余任务都因依赖问题无法执行")
+              break
+            end
+
+            # 没有可执行的任务，短暂休眠后重试
+            sleep(0.1)
+            next
+          end
+
+          # 原子操作：查找并获取资源锁
+          task = queue.find_and_remove do |t|
+            # 只检查是否是刚才找到的任务，并尝试获取资源
+            t.id == executable_task.id &&
+              resource_manager.try_acquire(t.required_resources, t.id)
+          end
+
+          # 如果获取失败（资源被占用），继续循环
+          next unless task
+
+          # 执行任务
+          executor.execute_task_sync(task, task_manager)
+        end
+      end
+
+      # 策略名称
+      # @return [String]
+      def name
+        "串行执行"
+      end
+    end
+  end
+end