pindo 5.11.1 → 5.11.3

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

@@ -0,0 +1,494 @@
+require 'singleton'
+require 'thread'
+
+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
+      end
+
+      # 添加任务
+      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
+
+        @queue_mutex.synchronize do
+          @pending_queue << task
+          # 按优先级排序
+          @pending_queue.sort_by! { |t| -t.priority }
+          # 通知等待的线程有新任务
+          @queue_condition.signal
+        end
+
+        task.id
+      end
+
+      # 批量添加任务
+      def add_tasks(tasks)
+        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
+            end
+
+            # 如果应该停止且没有任务，退出循环
+            break if should_stop_locked? && task.nil?
+          end
+
+          # 在锁外触发任务
+          if task
+            trigger_task(task)
+          end
+
+          # 清理已完成的异步任务
+          cleanup_finished_tasks
+        end
+
+        # 等待所有触发的任务完成
+        wait_all_triggered_tasks
+
+        puts "\n[TaskManager] 所有任务执行完毕".green if defined?(String.green)
+        @running = false
+      end
+
+      # 停止执行
+      def stop
+        @running = false
+      end
+
+      # 等待所有任务完成
+      def wait_all
+        while @pending_queue.any? || @running_tasks.any?
+          sleep(0.1)
+        end
+      end
+
+      # 获取任务状态
+      def task_status(task_id)
+        task = find_task(task_id)
+        task&.status
+      end
+
+      # 取消任务
+      def cancel_task(task_id)
+        task = find_task(task_id)
+        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
+      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)
+          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
+      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 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
+
+          # 将任务移到完成队列
+          @pending_queue.delete(task)
+          @completed_tasks << task
+        end
+      end
+
+      # 触发任务执行
+      def trigger_task(task)
+        # 获取任务锁
+        lock_acquired = acquire_lock(task)
+
+        unless lock_acquired
+          # 无法获取锁，任务返回队列
+          @queue_mutex.synchronize do
+            @pending_queue.unshift(task)  # 放回队列前面
+            @queue_condition.signal
+          end
+          return
+        end
+
+        @queue_mutex.synchronize do
+          task.status = TaskStatus::TRIGGERED
+          @triggered_queue << task
+          @running_tasks << task
+        end
+
+        # 显示触发信息
+        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}"
+
+        # 设置任务完成回调
+        task.on(:after) do |t|
+          on_task_finished(t)
+        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
+
+        # 根据执行类型触发任务
+        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
+      end
+
+      # 任务完成回调
+      def on_task_finished(task)
+        @queue_mutex.synchronize do
+          @running_tasks.delete(task)
+          @triggered_queue.delete(task)
+          @completed_tasks << task
+
+          # 释放任务锁
+          release_lock(task)
+
+          # 通知等待的线程，可能有新的任务可以执行
+          @queue_condition.signal
+        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
+      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
+      end
+
+      # 判断是否应该停止（需要在锁内调用）
+      def should_stop_locked?
+        @pending_queue.empty? && @running_tasks.empty?
+      end
+
+      # 判断是否应该停止（带锁版本）
+      def should_stop?
+        @queue_mutex.synchronize do
+          should_stop_locked?
+        end
+      end
+
+      # 等待所有已触发的任务完成
+      def wait_all_triggered_tasks
+        if defined?(String.yellow)
+          puts "\n等待所有异步任务完成...".yellow
+        else
+          puts "\n等待所有异步任务完成..."
+        end
+
+        while true
+          @queue_mutex.synchronize do
+            break if @triggered_queue.empty? && @running_tasks.empty?
+          end
+          sleep(0.1)
+        end
+      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 }
+      end
+
+      # 获取类型锁
+      def type_lock(type)
+        @task_locks[:type_locks][type] ||= Mutex.new
+      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
+      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
+        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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pindo/module/unity/unity_helper.rb

@@ -308,7 +308,7 @@ module Pindo
             # 检查是否有构建错误的关键词
             if stdout_buffer.match?(/Build completed with a result of 'Failed'|Build completed with a result of 'Cancelled'|BuildPlayerWindow\+BuildMethod\+Invoke|error|Error|ERROR|exception|Exception|EXCEPTION|failed|Failed|FAILED/)
               build_success = false
-              puts "\n\e[31m检测到构建错误信息，构建可能失败\e[0m"
+              # puts "\n\e[31m检测到构建错误信息，构建可能失败\e[0m"
             end
             
             if build_success
@@ -442,51 +442,27 @@ module Pindo
             puts result[:stdout]
           end
         else
-          puts "Unity build failed"
-          puts "Unity version: #{result[:unity_version]}"
-          puts "Exit status: #{result[:exit_status]}"
-          
-          if !result[:stdout].empty?
-            puts "Unity标准输出:"
-            puts result[:stdout]
-          end
-          
-          if !result[:stderr].empty?
-            puts "Unity错误输出:"
-            puts result[:stderr]
-          else
-            puts "Unity没有输出错误信息"
-          end
-          
-          # 提供更详细的错误信息
-          error_msg = "Unity构建失败 (退出码: #{result[:exit_status]})"
+          # 简单输出失败信息，不显示详细调试信息
+          puts "Unity构建失败！ "
+
+          # 构造简洁的错误信息
           
-          # 检查是否是Unity实例冲突错误
-          if !result[:stdout].empty? && result[:stdout].include?("Multiple Unity instances cannot open the same project")
-            error_msg = "Unity实例冲突错误：\n"
-            error_msg += "检测到另一个Unity实例正在运行并打开了同一个项目。\n"
-            error_msg += "请关闭所有Unity实例后重试。\n"
-            error_msg += "可以使用以下命令检查Unity进程：\n"
-            error_msg += "  ps aux | grep -i unity\n"
-            error_msg += "然后使用以下命令关闭Unity进程：\n"
-            error_msg += "  kill <进程ID>"
-          # 检查是否是Android SDK下载问题
-          elsif !result[:stdout].empty? && (result[:stdout].include?("Failed to download package") || result[:stdout].include?("Install Android SDK Platform"))
-            error_msg = "Android SDK下载问题：\n"
-            error_msg += "Unity在下载Android SDK组件时遇到网络问题。\n"
-            error_msg += "解决方案：\n"
-            error_msg += "1. 检查网络连接\n"
-            error_msg += "2. 使用VPN或代理\n"
-            error_msg += "3. 在Unity Editor中手动配置Android SDK路径\n"
-            error_msg += "4. 清理Unity缓存: rm -rf Library/BuildCache\n"
-            error_msg += "5. 重新运行构建命令"
-          elsif !result[:stderr].empty?
-            error_msg += "\n错误详情: #{result[:stderr].lines.first.strip}"
-          elsif !result[:stdout].empty?
-            error_msg += "\nUnity输出: #{result[:stdout].lines.first.strip}"
-          end
+          # # 检查特定错误类型，提供简洁的错误信息
+          # if !result[:stdout].empty? && result[:stdout].include?("Multiple Unity instances cannot open the same project")
+          #   error_msg = "Unity实例冲突：另一个Unity正在使用此项目，请关闭所有Unity实例后重试"
+          # elsif !result[:stdout].empty? && (result[:stdout].include?("Failed to download package") || result[:stdout].include?("Install Android SDK Platform"))
+          #   error_msg = "Android SDK下载失败：请检查网络连接或手动配置SDK路径"
+          # elsif !result[:stderr].empty?
+          #   # 只取第一行错误信息
+          #   first_error = result[:stderr].lines.first.strip
+          #   error_msg = "Unity构建失败: #{first_error}"
+          # elsif !result[:stdout].empty?
+          #   # 只取第一行输出信息，不添加"Unity输出:"前缀
+          #   first_output = result[:stdout].lines.first.strip
+          #   error_msg = "Unity构建失败: #{first_output}"
+          # end
           
-          raise error_msg
+          raise Informative, "GoodUnityBuild 导出时候失败！请确保GoodUnityBuild 能正常导出！！！"
         end
 
         result

data/lib/pindo/version.rb

@@ -6,7 +6,7 @@ require 'time'
 
 module Pindo
 
-  VERSION = "5.11.1"
+  VERSION = "5.11.3"
 
   class VersionCheck
     RUBYGEMS_API = 'https://rubygems.org/api/v1/gems/pindo.json'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pindo
 version: !ruby/object:Gem::Version
-  version: 5.11.1
+  version: 5.11.3
 platform: ruby
 authors:
 - wade
@@ -414,8 +414,8 @@ files:
 - lib/pindo/command/web/run.rb
 - lib/pindo/config/pindoconfig.rb
 - lib/pindo/config/pindouserlocalconfig.rb
-- lib/pindo/module/android/android_build_config_helper.rb
 - lib/pindo/module/android/android_build_helper.rb
+- lib/pindo/module/android/android_config_helper.rb
 - lib/pindo/module/android/android_project_helper.rb
 - lib/pindo/module/android/android_res_helper.rb
 - lib/pindo/module/android/gp_compliance_helper.rb
@@ -437,6 +437,12 @@ files:
 - lib/pindo/module/cert/provisioning_helper.rb
 - lib/pindo/module/cert/xcodecerthelper.rb
 - lib/pindo/module/pgyer/pgyerhelper.rb
+- lib/pindo/module/task/model/build_task.rb
+- lib/pindo/module/task/model/unity_export_task.rb
+- lib/pindo/module/task/model/upload_task.rb
+- lib/pindo/module/task/pindo_task.rb
+- lib/pindo/module/task/task_config.rb
+- lib/pindo/module/task/task_manager.rb
 - lib/pindo/module/unity/nuget_helper.rb
 - lib/pindo/module/unity/unity_helper.rb
 - lib/pindo/module/webserver/brotli_file_handler.rb