pindo 5.11.3 → 5.12.1

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

@@ -1,27 +1,13 @@
 require 'securerandom'
-require 'thread'
 
 module Pindo
   module TaskSystem
     # 任务取消异常
     class TaskCancelledException < StandardError; end
-    # 执行模式：控制并发策略
-    module ExecutionMode
-      EXCLUSIVE = :exclusive           # 独占：阻塞所有其他任务
-      TYPE_EXCLUSIVE = :type_exclusive # 类型独占：同类型串行
-      CONCURRENT = :concurrent         # 并发：可与任意任务并行
-    end
-
-    # 执行类型：控制在哪个线程执行
-    module ExecutionType
-      SYNC = :sync           # 同步执行（在主线程）
-      ASYNC = :async         # 异步执行（在新线程）
-    end
 
     # 任务状态
     module TaskStatus
       PENDING = :pending       # 待执行
-      TRIGGERED = :triggered   # 已触发
       RUNNING = :running       # 执行中
       SUCCESS = :success       # 成功
       FAILED = :failed         # 失败
@@ -36,77 +22,72 @@ module Pindo
       CRITICAL = 15
     end
 
-    # PindoTask 基类
+    # 重试模式
+    module RetryMode
+      IMMEDIATE = :immediate      # 立即重试
+      DELAYED = :delayed          # 延迟重试
+      NEXT_TASK = :next_task      # 下个任务重试
+    end
+
+    # PindoTask 基类（简化版，所有任务在主线程中执行）
     class PindoTask
-      attr_accessor :id, :name, :status, :error, :result, :progress, :progress_message
-      attr_reader :type, :execution_mode, :execution_type, :priority, :dependencies
-      attr_accessor :context, :metadata, :thread
+      attr_accessor :id, :name, :status, :error, :result
+      attr_reader :type, :priority, :dependencies
+      attr_accessor :context, :metadata
       attr_reader :created_at, :started_at, :finished_at
+      attr_accessor :retry_count  # 剩余重试次数
+      attr_reader :retry_mode, :retry_delay
+      attr_accessor :callbacks_setup  # 标记回调是否已经设置
 
       def initialize(name, options = {})
         @id = SecureRandom.uuid
         @name = name
         @type = self.class.task_type
-        @execution_mode = options[:execution_mode] || self.class.execution_mode
-        @execution_type = options[:execution_type] || self.class.execution_type
-        @priority = options[:priority] || TaskPriority::NORMAL
+        @priority = options[:priority] || TaskPriority::HIGH
         @status = TaskStatus::PENDING
         @dependencies = options[:dependencies] || []
         @context = options[:context] || {}
         @metadata = options[:metadata] || {}
-        @progress = 0
-        @progress_message = nil
         @error = nil
         @result = nil
-        @thread = nil  # 执行线程
         @created_at = Time.now
         @started_at = nil
         @finished_at = nil
-        @mutex = Mutex.new
-        @condition = ConditionVariable.new
         @callbacks = {
           before: [],
           after: [],
           on_success: [],
-          on_failure: [],
-          on_progress: []
+          on_failure: []
         }
+        @callbacks_setup = false
+
+        # 重试配置
+        @retry_mode = options[:retry_mode] || self.class.default_retry_mode
+        @retry_count = options[:retry_count] || self.class.default_retry_count
+        @retry_delay = options[:retry_delay] || self.class.default_retry_delay
       end
 
-      # 子类配置
+      # 子类必须实现的方法
       def self.task_type
         raise NotImplementedError, "Subclass must define task_type"
       end
 
-      def self.execution_mode
-        ExecutionMode::TYPE_EXCLUSIVE  # 默认同类型串行
+      # 默认重试配置
+      def self.default_retry_mode
+        RetryMode::IMMEDIATE
       end
 
-      def self.execution_type
-        ExecutionType::ASYNC  # 默认异步执行
+      def self.default_retry_count
+        0  # 默认不重试
       end
 
-      # 同步执行（在当前线程）
-      def do_task
-        execute_internal
+      def self.default_retry_delay
+        10  # 默认延迟 10 秒
       end
 
-      # 异步执行（在新线程）
-      def async_do_task
-        @thread = Thread.new do
-          begin
-            execute_internal
-          rescue => e
-            @error = e
-            @status = TaskStatus::FAILED
-            puts "[Task Error] #{@name}: #{e.message}".red if defined?(String.red)
-          end
-        end
-      end
-
-      # 等待异步任务完成
-      def wait
-        @thread&.join
+      # 执行任务（在主线程中同步执行）
+      def do_task
+        execute_internal
       end
 
       # 检查是否完成
@@ -126,14 +107,11 @@ module Pindo
 
       # 取消任务
       def cancel
-        @mutex.synchronize do
-          if @status == TaskStatus::PENDING || @status == TaskStatus::TRIGGERED
-            @status = TaskStatus::CANCELLED
-            @condition.signal
-            true
-          else
-            false
-          end
+        if @status == TaskStatus::PENDING
+          @status = TaskStatus::CANCELLED
+          true
+        else
+          false
         end
       end
 
@@ -144,16 +122,6 @@ module Pindo
         end_time - @started_at
       end
 
-      # 更新进度
-      def update_progress(value, message = nil)
-        # 检查是否已取消
-        check_cancelled!
-
-        @progress = value.clamp(0, 100)
-        @progress_message = message
-        run_callbacks(:on_progress)
-      end
-
       # 检查是否已取消，如果已取消则抛出异常
       def check_cancelled!
         if @status == TaskStatus::CANCELLED
@@ -171,6 +139,26 @@ module Pindo
         @callbacks[event] << block if @callbacks[event]
       end
 
+      # 重试相关方法
+      def retryable?
+        @retry_count > 0
+      end
+
+      def should_retry?(error)
+        true  # 默认所有错误都重试，子类可重写
+      end
+
+      def before_retry
+        # 子类可重写，进行重试前的清理工作
+      end
+
+      def reset_for_retry
+        @status = TaskStatus::PENDING
+        @result = nil
+        @started_at = nil
+        @finished_at = nil
+      end
+
       protected
 
       # 子类必须实现
@@ -183,48 +171,100 @@ module Pindo
       # 内部执行逻辑
       def execute_internal
         begin
-          @mutex.synchronize do
-            return if @status == TaskStatus::CANCELLED
-            @status = TaskStatus::RUNNING
-            @started_at = Time.now
-          end
+          @status = TaskStatus::RUNNING
+          @started_at = Time.now
 
           run_callbacks(:before)
 
           # 子类实现具体逻辑
           @result = do_work
 
-          @mutex.synchronize do
-            @status = TaskStatus::SUCCESS
-            @condition.signal
-          end
+          @status = TaskStatus::SUCCESS
 
           run_callbacks(:on_success)
         rescue TaskCancelledException => e
           # 任务被取消
-          @mutex.synchronize do
-            @status = TaskStatus::CANCELLED
-            @error = e
-            @condition.signal
-          end
-
+          @status = TaskStatus::CANCELLED
+          @error = e
           puts "[Task] #{@name} 已被取消".yellow if defined?(String.yellow)
-          # 不抛出异常，正常结束
         rescue => e
-          @mutex.synchronize do
-            @error = e
-            @status = TaskStatus::FAILED
-            @condition.signal
-          end
-
-          run_callbacks(:on_failure)
-          raise if should_raise_on_failure?
+          handle_failure(e)
         ensure
           @finished_at = Time.now
           run_callbacks(:after)
         end
       end
 
+      # 处理失败
+      def handle_failure(error)
+        @error = error
+
+        # 判断是否可以重试
+        if retryable? && should_retry?(error)
+          # 递减重试次数
+          @retry_count -= 1
+
+          # 根据重试模式处理
+          case @retry_mode
+          when RetryMode::IMMEDIATE
+            handle_immediate_retry
+          when RetryMode::DELAYED
+            handle_delayed_retry
+          when RetryMode::NEXT_TASK
+            handle_next_task_retry
+          else
+            finalize_failure
+          end
+        else
+          finalize_failure
+        end
+      end
+
+      # 立即重试
+      def handle_immediate_retry
+        puts "⚠️  任务失败，立即重试 (剩余#{@retry_count}次)".yellow if defined?(String.yellow)
+        puts "  错误: #{@error.message}"
+
+        before_retry
+        reset_for_retry
+        execute_internal
+      end
+
+      # 延迟重试
+      def handle_delayed_retry
+        puts "⚠️  任务失败，延迟重试 (剩余#{@retry_count}次)".yellow if defined?(String.yellow)
+        puts "  错误: #{@error.message}"
+        puts "  延迟: #{@retry_delay}秒"
+
+        before_retry
+        sleep(@retry_delay) if @retry_delay > 0
+
+        reset_for_retry
+        execute_internal
+      end
+
+      # 下个任务重试
+      def handle_next_task_retry
+        puts "⚠️  任务失败，下个任务重试 (剩余#{@retry_count}次)".yellow if defined?(String.yellow)
+        puts "  错误: #{@error.message}"
+
+        before_retry
+        @status = TaskStatus::FAILED
+        run_callbacks(:on_failure)
+        raise @error if should_raise_on_failure?
+      end
+
+      # 最终失败
+      def finalize_failure
+        @status = TaskStatus::FAILED
+
+        puts "[Task] #{@name} 最终失败".red if defined?(String.red)
+        puts "  错误: #{@error.message}".red if defined?(String.red)
+
+        run_callbacks(:on_failure)
+        raise @error if should_raise_on_failure?
+      end
+
       def run_callbacks(event)
         @callbacks[event].each { |cb| cb.call(self) }
       end
@@ -234,4 +274,4 @@ module Pindo
       end
     end
   end
-end
+end