pindo 5.13.12 → 5.13.13

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

@@ -0,0 +1,131 @@
+require_relative '../output/stdout_redirector'
+
+module Pindo
+  module TaskSystem
+    # TaskExecutor - 任务执行器
+    #
+    # 职责：
+    # - 执行单个任务
+    # - 处理输出管理器模式和传统模式
+    # - 管理任务回调和上下文
+    # - 管理任务资源锁定和释放
+    class TaskExecutor
+      def initialize(queue, reporter, resource_lock_manager, output_manager = nil)
+        @queue = queue
+        @reporter = reporter
+        @resource_lock_manager = resource_lock_manager
+        @output_manager = output_manager
+      end
+
+      # 设置输出管理器
+      # @param output_manager [MultiLineOutputManager] 输出管理器
+      def output_manager=(output_manager)
+        @output_manager = output_manager
+      end
+
+      # 执行单个任务
+      # @param task [PindoTask] 任务对象
+      # @param task_manager [TaskManager] 任务管理器（用于依赖注入）
+      def execute_task_sync(task, task_manager)
+        begin
+          # 注入 TaskManager 实例（依赖注入）
+          task.task_manager = task_manager
+
+          # 设置任务进度回调
+          setup_task_callbacks(task)
+
+          # 注意：资源锁已经在 ExecutionStrategy 的 find_and_remove 中原子获取
+          # 这里不需要再次获取，只需要在 ensure 中释放
+
+          # 根据是否有输出管理器选择执行模式
+          if @output_manager
+            execute_task_with_output_manager(task)
+          else
+            execute_task_legacy(task)
+          end
+
+          # 将任务移到完成队列
+          @queue.mark_completed(task)
+        ensure
+          # 自动释放任务占用的资源
+          @resource_lock_manager.release(task.id)
+        end
+      end
+
+      private
+
+      # 设置任务回调
+      # @param task [PindoTask] 任务对象
+      def setup_task_callbacks(task)
+        # 只在第一次设置回调
+        return if task.callbacks_setup
+
+        # 主线程执行不需要进度回调
+
+        task.callbacks_setup = true
+      end
+
+      # 使用输出管理器执行任务（并发模式）
+      # @param task [PindoTask] 任务对象
+      def execute_task_with_output_manager(task)
+        # 注入输出上下文到线程局部变量
+        Thread.current[:output_sink] = @output_manager
+        Thread.current[:task_id] = task.id
+
+        begin
+          # 启动任务显示
+          @output_manager.start_task(task.id)
+
+          # 使用 stdout 重定向包裹任务执行
+          StdoutRedirector.redirect_for_task(task.id, @output_manager) do
+            task.do_task
+          end
+
+          # 任务成功
+          @output_manager.success_task(task.id, execution_time: task.execution_time)
+
+        rescue => e
+          # 任务失败
+          @output_manager.error_task(task.id, e.message)
+          task.status = TaskStatus::FAILED
+          task.error = e
+
+          # 如果在调试模式，打印堆栈信息
+          if ENV['PINDO_DEBUG'] && e.backtrace && !e.backtrace.empty?
+            @output_manager.log_detail(task.id, "\n堆栈信息:")
+            e.backtrace.first(10).each do |line|
+              @output_manager.log_detail(task.id, "  #{line}")
+            end
+          end
+
+        ensure
+          # 清理线程上下文
+          Thread.current[:output_sink] = nil
+          Thread.current[:task_id] = nil
+        end
+      end
+
+      # 传统串行模式执行任务
+      # @param task [PindoTask] 任务对象
+      def execute_task_legacy(task)
+        # 显示任务开始信息
+        @reporter.print_task_header(task)
+
+        begin
+          # 在主线程中执行任务
+          task.do_task
+
+          # 任务成功
+          @reporter.print_task_success(task)
+
+        rescue => e
+          # 任务失败
+          @reporter.print_task_failure(task, e)
+        end
+
+        # 任务完成后输出分隔线
+        @reporter.print_task_footer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+require 'thread'
+
+module Pindo
+  module TaskSystem
+    # TaskQueue - 任务队列管理
+    #
+    # 职责：
+    # - 管理待执行队列、已完成队列和当前任务
+    # - 提供线程安全的队列操作
+    # - 提供原子操作 API
+    # - 提供高级查询功能（分组、统计）
+    class TaskQueue
+      def initialize
+        @pending = []      # 待执行队列
+        @running = []      # 正在运行队列（用于并发执行）
+        @completed = []    # 已完成队列
+        @current = nil     # 当前正在执行的任务（用于串行执行）
+        @mutex = Mutex.new # 线程安全锁
+      end
+
+      # ==================== 原子操作 ====================
+
+      # 添加任务（线程安全）
+      # @param task [PindoTask] 任务对象
+      # @param sort_by_priority [Boolean] 是否按优先级排序
+      # @return [String] 任务 ID
+      def add(task, sort_by_priority: true)
+        @mutex.synchronize do
+          @pending << task
+          @pending.sort_by! { |t| -t.priority } if sort_by_priority
+          task.id
+        end
+      end
+
+      # 批量添加任务
+      # @param tasks [Array<PindoTask>] 任务数组
+      # @return [Array<String>] 任务 ID 数组
+      def add_all(tasks)
+        @mutex.synchronize do
+          @pending.concat(tasks)
+          @pending.sort_by! { |t| -t.priority }
+          tasks.map(&:id)
+        end
+      end
+
+      # 查找并移除任务（原子操作）
+      # @yield [task] 查找条件
+      # @yieldparam task [PindoTask] 任务对象
+      # @yieldreturn [Boolean] 是否匹配
+      # @return [PindoTask, nil] 找到的任务
+      def find_and_remove(&block)
+        @mutex.synchronize do
+          task = @pending.find(&block)
+          @pending.delete(task) if task
+          task
+        end
+      end
+
+      # 设置当前任务（串行执行使用）
+      # @param task [PindoTask] 任务对象
+      def set_current(task)
+        @mutex.synchronize { @current = task }
+      end
+
+      # 获取当前任务
+      # @return [PindoTask, nil] 当前任务
+      def current
+        @mutex.synchronize { @current }
+      end
+
+      # 添加正在运行的任务（并发执行使用）
+      # @param task [PindoTask] 任务对象
+      def add_running(task)
+        @mutex.synchronize { @running << task unless @running.include?(task) }
+      end
+
+      # 移除正在运行的任务（并发执行使用）
+      # @param task [PindoTask] 任务对象
+      # @return [Boolean] 是否成功移除
+      def remove_running(task)
+        @mutex.synchronize { @running.delete(task) != nil }
+      end
+
+      # 完成当前任务（原子操作）
+      # @return [PindoTask, nil] 完成的任务
+      def complete_current
+        @mutex.synchronize do
+          return nil unless @current
+          task = @current
+          @completed << task
+          @current = nil
+          task
+        end
+      end
+
+      # 移除待执行任务（用于标记失败/取消）
+      # @param task [PindoTask] 任务对象
+      # @return [Boolean] 是否成功移除
+      def remove_pending(task)
+        @mutex.synchronize do
+          @pending.delete(task) != nil
+        end
+      end
+
+      # 添加到已完成队列
+      # @param task [PindoTask] 任务对象
+      def mark_completed(task)
+        @mutex.synchronize do
+          @completed << task unless @completed.include?(task)
+        end
+      end
+
+      # ==================== 查询操作 ====================
+
+      # 返回待执行队列快照（不持锁遍历）
+      # @return [Array<PindoTask>] 队列副本
+      def pending_snapshot
+        @mutex.synchronize { @pending.dup }
+      end
+
+      # 返回已完成队列快照
+      # @return [Array<PindoTask>] 队列副本
+      def completed_snapshot
+        @mutex.synchronize { @completed.dup }
+      end
+
+      # 按类型分组待执行任务
+      # @return [Hash{Symbol => Array<PindoTask>}] 分组结果
+      def pending_grouped_by_type
+        @mutex.synchronize { @pending.group_by(&:type) }
+      end
+
+      # 按状态统计已完成任务
+      # @return [Hash{Symbol => Integer}] 状态计数
+      def completed_count_by_status
+        @mutex.synchronize do
+          @completed.group_by(&:status).transform_values(&:count)
+        end
+      end
+
+      # 查找任务（在所有队列中）
+      # @param task_id [String] 任务 ID
+      # @return [PindoTask, nil] 任务对象
+      def find(task_id)
+        @mutex.synchronize do
+          all_tasks = @pending + @running + @completed
+          all_tasks << @current if @current
+          all_tasks.find { |t| t.id == task_id }
+        end
+      end
+
+      # 检查待执行队列是否为空
+      # @return [Boolean]
+      def pending_empty?
+        @mutex.synchronize { @pending.empty? }
+      end
+
+      # 检查是否有当前任务
+      # @return [Boolean]
+      def has_current?
+        @mutex.synchronize { !@current.nil? }
+      end
+
+      # 获取待执行任务数量
+      # @return [Integer]
+      def pending_count
+        @mutex.synchronize { @pending.size }
+      end
+
+      # 获取已完成任务数量
+      # @return [Integer]
+      def completed_count
+        @mutex.synchronize { @completed.size }
+      end
+
+      # ==================== 队列管理 ====================
+
+      # 清空所有队列
+      def clear_all
+        @mutex.synchronize do
+          @pending.clear
+          @running.clear
+          @completed.clear
+          @current = nil
+        end
+      end
+
+      # 获取所有任务
+      # @return [Array<PindoTask>] 所有任务
+      def all_tasks
+        @mutex.synchronize do
+          tasks = @pending + @running + @completed
+          tasks << @current if @current
+          tasks
+        end
+      end
+
+      # 条件查找（在待执行队列中）
+      # @yield [task] 查找条件
+      # @yieldparam task [PindoTask] 任务对象
+      # @yieldreturn [Boolean] 是否匹配
+      # @return [PindoTask, nil] 找到的任务（不移除）
+      def find_pending(&block)
+        @mutex.synchronize do
+          @pending.find(&block)
+        end
+      end
+
+      # 检查所有待执行任务是否满足条件
+      # @yield [task] 检查条件
+      # @yieldparam task [PindoTask] 任务对象
+      # @yieldreturn [Boolean] 是否满足
+      # @return [Boolean]
+      def all_pending?(&block)
+        @mutex.synchronize do
+          @pending.all?(&block)
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/task/model/build/android_build_dev_task.rb

@@ -39,7 +39,7 @@ module Pindo
 
       def prepare_build
         # 校验必需的参数
-        Dir.chdir(@project_path)
+        # Dir.chdir(@project_path) # Removed for thread safety
         validate_workflow_info
         update_project_config
         update_version_info

data/lib/pindo/module/task/model/build/android_build_task.rb

@@ -6,8 +6,12 @@ module Pindo
     # 所有 Android 平台构建任务的抽象基类
     # 子类包括：AndroidBuildDevTask、AndroidBuildAdhocTask、AndroidBuildGPlayTask
     class AndroidBuildTask < BuildTask
-      # 空基类，仅用于类型标识
-      # 所有具体实现由子类完成
+
+      # 声明所需资源 - 基于项目目录锁定 Gradle 构建
+      # 确保同一项目的 Gradle 构建任务串行执行，避免并发冲突
+      def required_resources
+        (super || []) + [{ type: :gradle, directory: @project_path }]
+      end
     end
   end
 end

data/lib/pindo/module/task/model/build/ios_build_dev_task.rb

@@ -47,7 +47,7 @@ module Pindo
         # 校验必需的参数
         validate_workflow_info
 
-        Dir.chdir(@project_path)
+        # Dir.chdir(@project_path) # Removed for thread safety
         cleanup_firebase_shell
         update_project_config
         update_version_info
@@ -214,7 +214,6 @@ module Pindo
           @macos_flag = true
         end
       end
-
       # 更新 URL Schemes（基于最终 Bundle ID）
       def update_url_schemes_final
         workflow_packname = @workflow_info[:package_name]
@@ -226,7 +225,7 @@ module Pindo
 
       # 编译 iOS 工程
       def build_ios_project
-        Dir.chdir(@project_path)
+        # Dir.chdir(@project_path) # Removed for thread safety
 
         # 使用 XcodeBuildHelper 进行构建
         ipa_file = Pindo::XcodeBuildHelper.build_project(

data/lib/pindo/module/task/model/build/ios_build_task.rb

@@ -8,6 +8,12 @@ module Pindo
     # 子类包括：IosBuildDevTask、IosBuildAdhocTask、IosBuildAppStoreTask
     class IosBuildTask < BuildTask
 
+      # 声明所需资源 - 基于项目目录锁定 Xcode 构建
+      # 确保同一项目的 Xcode 构建任务串行执行，避免并发冲突
+      def required_resources
+        (super || []) + [{ type: :xcode, directory: @project_path }]
+      end
+
       protected
 
       # 清理 Firebase Shell Script

data/lib/pindo/module/task/model/build_task.rb

@@ -1,5 +1,6 @@
 require_relative '../pindo_task'
 require_relative '../task_config'
+require 'pindo/base/git_handler'
 
 module Pindo
   module TaskSystem
@@ -31,6 +32,13 @@ module Pindo
         10
       end
 
+      # 声明所需资源 - 添加通用的 build 资源锁
+      # 确保同一项目（git 仓库或目录）下的所有构建任务串行执行
+      def required_resources
+        build_lock_dir = get_build_lock_directory
+        (super || []) + [{ type: :build, directory: build_lock_dir }]
+      end
+
       # ========== 静态工厂方法 ==========
 
       # 根据 platform 和 mode 创建对应的构建任务实例
@@ -146,6 +154,20 @@ module Pindo
 
       protected
 
+      # 获取 build 资源锁定的目录
+      # 优先使用 git 根目录（如果在 git 仓库内），否则使用项目目录
+      # 这样可以确保同一 git 仓库下的所有构建任务串行执行
+      def get_build_lock_directory
+        return @project_path unless @project_path
+
+        begin
+          git_root = Pindo::GitHandler.git_root_directory(local_repo_dir: @project_path)
+          git_root || @project_path
+        rescue
+          @project_path
+        end
+      end
+
       # 主执行流程
       def do_work
         # 准备构建

data/lib/pindo/module/task/model/git/git_commit_task.rb

@@ -28,12 +28,16 @@ module Pindo
       #   - tag_type: 创建tag类型，默认 :new
       #   - tag_pre: tag前缀，默认 'v'
       #   - fixed_version: 外部指定的固定版本号，如果设置则跳过版本号计算
+      #   - process_type: 未提交文件的处理方式 ('skip', 'commit', 'reset', 'stash')，默认 'skip'
+      #   - commit_message: 提交消息，默认 'build: 构建产生提交'
       def initialize(project_path, options = {})
         @release_branch = options[:release_branch] || 'master'
         @ver_inc = options[:ver_inc] || Pindo::VersionIncreaseType::MINI
         @tag_type = options[:tag_type] || Pindo::CreateTagType::NEW
         @tag_pre = options[:tag_pre] || 'v'
         @fixed_version = options[:fixed_version]  # 外部指定的固定版本号
+        @process_type = options[:process_type] || 'skip' # 默认跳过
+        @commit_message = options[:commit_message] || 'build: 构建产生提交' # 默认提交消息
 
         @build_version = nil
         @build_number = nil
@@ -70,14 +74,19 @@ module Pindo
         git_repo_helper.check_gitignore(root_dir)
 
         # 2. 检查并处理未提交的文件（使用 GitHandler）
+        # process_type 已经在初始化时确定（由外部传入或默认为 skip）
         begin
-          Pindo::GitHandler.check_uncommitted_files(project_dir: root_dir)
+            Pindo::GitHandler.process_need_add_files(
+                project_dir: root_dir,
+                process_type: @process_type || 'skip',
+                commit_message: @commit_message
+            )
         rescue Informative => e
           # 用户选择手动处理时，不需要重试
           if e.message.include?("请手动处理")
             @retry_count = 0
           end
-          raise
+          raise Informative "GitCommitTask 任务失败！"
         end
 
         # 3. 获取当前分支

data/lib/pindo/module/task/model/git_task.rb

@@ -52,6 +52,12 @@ module Pindo
         true
       end
 
+      # 声明所需资源 - 基于仓库路径锁定 Git 操作
+      # 确保同一仓库的 Git 任务串行执行，避免并发冲突
+      def required_resources
+        (super || []) + [{ type: :git, directory: @git_root_path }]
+      end
+
       protected
 
       # 检查是否为 Git 仓库

data/lib/pindo/module/task/model/jps/jps_message_task.rb

@@ -102,19 +102,17 @@ module Pindo
 
       # 从依赖任务获取数据
       def fetch_data_from_dependencies
-        # 优先从 data_dependencies 获取数据（新机制）
-        unless @data_dependencies.empty?
-          upload_data = get_data_param_by_key(:jps_upload)
-
-          if upload_data && upload_data[:task_param]
-            param = upload_data[:task_param]
-            @app_version_info = param[:app_version_info] if @app_version_info.nil?
-            @app_info_obj = param[:app_info_obj] if @app_info_obj.nil?
-            return
-          end
+        # 从 dependencies 获取数据
+        upload_data = get_data_param_by_key(:jps_upload)
+
+        if upload_data && upload_data[:task_param]
+          param = upload_data[:task_param]
+          @app_version_info = param[:app_version_info] if @app_version_info.nil?
+          @app_info_obj = param[:app_info_obj] if @app_info_obj.nil?
+          return
         end
 
-        # 兼容旧机制：从 dependencies 获取数据（向后兼容）
+        # 兼容旧机制：从第一个依赖获取结果
         unless @dependencies.empty?
           upload_result = get_dependency_result(@dependencies.first)