ruby_reactor 0.1.0 → 0.3.0

data/lib/ruby_reactor/executor/result_handler.rb

@@ -15,62 +15,30 @@ module RubyReactor
       def handle_step_result(step_config, result, resolved_arguments)
         case result
         when RubyReactor::Success
-          validate_step_output(step_config, result.value, resolved_arguments)
-          @step_results[step_config.name] = result
-          @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments, result: result })
-          @context.set_result(step_config.name, result.value)
-          @dependency_graph.complete_step(step_config.name)
+          handle_success(step_config, result, resolved_arguments)
         when RubyReactor::MaxRetriesExhaustedFailure
-          # For MaxRetriesExhaustedFailure, use the original error to avoid double-wrapping the message
-          # The error message from MaxRetriesExhaustedFailure already includes "failed after N attempts"
-          @compensation_manager.handle_step_failure(step_config, result.original_error, resolved_arguments)
-          # Use the MaxRetriesExhaustedFailure error message for the final error
-          raise Error::StepFailureError.new(result.error, step: step_config.name, context: @context,
-                                                          step_arguments: resolved_arguments)
+          handle_retries_exhausted(step_config, result, resolved_arguments)
         when RubyReactor::Failure
-          failure_result = @compensation_manager.handle_step_failure(step_config, result.error, resolved_arguments)
-          raise Error::StepFailureError.new(failure_result.error, step: step_config.name, context: @context,
-                                                                  step_arguments: resolved_arguments)
+          handle_failure(step_config, result, resolved_arguments)
         else
-          # Treat non-Success/Failure results as success with that value
-          validate_step_output(step_config, result, resolved_arguments)
-          success_result = RubyReactor.Success(result)
-          @step_results[step_config.name] = success_result
-          @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
-                                                    result: success_result })
-          @context.set_result(step_config.name, result)
-          @dependency_graph.complete_step(step_config.name)
+          handle_unknown_result(step_config, result, resolved_arguments)
         end
       end
 
       def handle_execution_error(error)
         case error
         when Error::StepFailureError
-          # Step failure has already been handled (compensation and rollback for the failed step)
-          # But we need to rollback all completed steps
-          @compensation_manager.rollback_completed_steps
-
-          redact_inputs = error.context.reactor_class.inputs.select { |_, config| config[:redact] }.keys
-
-          RubyReactor::Failure(
-            error.message,
-            step_name: error.step,
-            inputs: error.context.inputs,
-            redact_inputs: redact_inputs,
-            backtrace: error.backtrace,
-            reactor_name: error.context.reactor_class.name,
-            step_arguments: error.step_arguments
-          )
+          handle_step_failure_error(error)
         when Error::InputValidationError
           # Preserve validation errors as-is for proper error handling
           RubyReactor.Failure(error)
         when Error::Base
           # Other errors need rollback
           @compensation_manager.rollback_completed_steps
-          RubyReactor.Failure("Execution error: #{error.message}")
+          RubyReactor.Failure("Execution error: #{error.message}", exception_class: error.class.name)
         else
           # Unknown errors - don't rollback as they may not be reactor-related
-          RubyReactor.Failure("Execution failed: #{error.message}")
+          RubyReactor.Failure("Execution failed: #{error.message}", exception_class: error.class.name)
         end
       end
 
@@ -85,6 +53,102 @@ module RubyReactor
 
       private
 
+      def handle_success(step_config, result, resolved_arguments)
+        validate_step_output(step_config, result.value, resolved_arguments)
+        @step_results[step_config.name] = result
+        @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments, result: result })
+        @context.set_result(step_config.name, result.value)
+        @dependency_graph.complete_step(step_config.name)
+      end
+
+      def handle_retries_exhausted(step_config, result, resolved_arguments)
+        @compensation_manager.handle_step_failure(step_config, result.original_error, resolved_arguments)
+        orig_err = result.original_error.is_a?(Exception) ? result.original_error : nil
+        error = Error::StepFailureError.new(result.error, step: step_config.name, context: @context,
+                                                          original_error: orig_err,
+                                                          step_arguments: resolved_arguments)
+        if result.respond_to?(:backtrace) && result.backtrace
+          error.set_backtrace(result.backtrace)
+        elsif orig_err
+          error.set_backtrace(orig_err.backtrace)
+        end
+        raise error
+      end
+
+      def handle_failure(step_config, result, resolved_arguments)
+        failure_result = @compensation_manager.handle_step_failure(step_config, result.error, resolved_arguments)
+        orig_err = result.error.is_a?(Exception) ? result.error : nil
+        error = Error::StepFailureError.new(failure_result.error, step: step_config.name, context: @context,
+                                                                  original_error: orig_err,
+                                                                  step_arguments: resolved_arguments)
+        if result.respond_to?(:backtrace) && result.backtrace
+          error.set_backtrace(result.backtrace)
+        elsif orig_err
+          error.set_backtrace(orig_err.backtrace)
+        end
+        raise error
+      end
+
+      def handle_unknown_result(step_config, result, resolved_arguments)
+        validate_step_output(step_config, result, resolved_arguments)
+        success_result = RubyReactor.Success(result)
+        @step_results[step_config.name] = success_result
+        @compensation_manager.add_to_undo_stack({ step: step_config, arguments: resolved_arguments,
+                                                  result: success_result })
+        @context.set_result(step_config.name, result)
+        @dependency_graph.complete_step(step_config.name)
+      end
+
+      def handle_step_failure_error(error)
+        current_context = error.context || @context
+        current_context.current_step = error.step
+
+        store_failed_map_context(current_context) if current_context.map_metadata
+
+        @compensation_manager.rollback_completed_steps
+
+        redact_inputs = []
+        if error.context&.reactor_class
+          redact_inputs = error.context.reactor_class.inputs.select { |_, config| config[:redact] }.keys
+        end
+
+        create_failure_from_error(error, redact_inputs)
+      end
+
+      def store_failed_map_context(context)
+        return unless context.map_metadata && context.map_metadata[:map_id]
+        return unless context.map_metadata[:fail_fast]
+
+        storage = RubyReactor.configuration.storage_adapter
+        storage.store_map_failed_context_id(
+          context.map_metadata[:map_id],
+          context.context_id,
+          context.map_metadata[:parent_reactor_class_name]
+        )
+      end
+
+      def create_failure_from_error(error, redact_inputs)
+        original_error = error.original_error
+        exception_class = original_error&.class&.name
+        backtrace = original_error&.backtrace || error.backtrace
+        file_path, line_number = extract_location(backtrace)
+        code_snippet = RubyReactor::Utils::CodeExtractor.extract(file_path, line_number) if file_path
+
+        RubyReactor.Failure(
+          error.message,
+          step_name: error.step,
+          inputs: error.context.inputs,
+          redact_inputs: redact_inputs,
+          backtrace: backtrace,
+          reactor_name: error.context.reactor_class.name,
+          step_arguments: error.step_arguments,
+          exception_class: exception_class,
+          file_path: file_path,
+          line_number: line_number,
+          code_snippet: code_snippet
+        )
+      end
+
       def validate_step_output(step_config, value, resolved_arguments = {})
         return unless step_config.output_validator
 
@@ -98,6 +162,21 @@ module RubyReactor
           step_arguments: resolved_arguments
         )
       end
+
+      def extract_location(backtrace)
+        return [nil, nil] unless backtrace && !backtrace.empty?
+
+        # Filter out internal reactor frames if needed, or just take the first one
+        # For now, let's take the first line of the backtrace which should be the error source
+        # But we might want to skip our own internal frames if we want to point to user code
+        # Let's start with the top frame, assuming backtrace is already correct (from original error)
+
+        first_line = backtrace.first
+        match = first_line.match(/^(.+?):(\d+)(?::in `.*')?$/)
+        return [nil, nil] unless match
+
+        [match[1], match[2].to_i]
+      end
     end
   end
 end

data/lib/ruby_reactor/executor/retry_manager.rb

@@ -34,11 +34,22 @@ module RubyReactor
       end
 
       def requeue_job_for_step_retry(step_config, error, reactor_class)
+        @context.current_step = step_config.name
         delay = calculate_backoff_delay(step_config, error, reactor_class)
 
         # Serialize context and requeue the job
         # Use root context if available to ensure we serialize the full tree
-        context_to_serialize = @context.root_context || @context
+        # BUT for map elements (which have map_metadata), we must serialize the element context itself
+
+        context_to_serialize = if @context.map_metadata
+                                 @context
+                               else
+                                 @context.root_context || @context
+                               end
+
+        puts "SERIALIZING CONTEXT: #{context_to_serialize.reactor_class.name}"
+        puts "INPUTS KEYS: #{context_to_serialize.inputs.keys}" if context_to_serialize.respond_to?(:inputs)
+
         reactor_class_name = context_to_serialize.reactor_class.name
 
         serialized_context = ContextSerializer.serialize(context_to_serialize)

data/lib/ruby_reactor/executor/step_executor.rb

@@ -36,6 +36,9 @@ module RubyReactor
             # If a step returns Failure, we need to stop execution and return it
             return result if result.is_a?(RubyReactor::Failure)
 
+            # If a step returns InterruptResult, we need to stop execution and return it
+            return result if result.is_a?(RubyReactor::InterruptResult)
+
             # If result is nil, it means async was executed inline (test mode), continue
             next if result.nil?
           end
@@ -49,7 +52,13 @@ module RubyReactor
         # If we're already in inline async execution mode (inside Worker),
         # treat async steps as sync to avoid infinite recursion
 
-        if step_config.async? && !@context.inline_async_execution
+        if @dependency_graph.completed.include?(step_config.name)
+          return RubyReactor.Success(@context.get_result(step_config.name))
+        end
+
+        if step_config.interrupt?
+          handle_interrupt_step(step_config)
+        elsif step_config.async? && !@context.inline_async_execution
           handle_async_step(step_config)
         else
           execute_step_with_retry(step_config)
@@ -77,8 +86,10 @@ module RubyReactor
         # Update retry context
         @context.retry_context = other_executor.context.retry_context
 
-        # Clear current_step since we've completed it
-        @context.current_step = nil
+        # Update current_step:
+        # If the other executor has a current_step, it means it paused/interrupted there. We should adopt it.
+        # If it's nil, it means it completed successfully, so we clear our current_step (which was the async step).
+        @context.current_step = other_executor.context.current_step
 
         # Update our dependency graph to reflect completed steps
         other_executor.context.intermediate_results.each_key do |step_name|
@@ -91,7 +102,8 @@ module RubyReactor
         # Merge any undo stack items
         other_executor.undo_stack.each do |item|
           # Avoid duplicates by checking if this step is already in the undo stack
-          unless @compensation_manager.undo_stack.any? { |existing| existing[:step].name == item[:step].name }
+          # Use string comparison for step names to avoid symbol/string mismatch issues
+          unless @compensation_manager.undo_stack.any? { |existing| existing[:step].name.to_s == item[:step].name.to_s }
             @compensation_manager.add_to_undo_stack(item)
           end
         end
@@ -248,6 +260,28 @@ module RubyReactor
         result.result
       end
 
+      def handle_interrupt_step(step_config)
+        # Check if we have a result for this step (resuming)
+        if @context.intermediate_results.key?(step_config.name)
+          # We are resuming
+          result = @context.get_result(step_config.name)
+          return RubyReactor.Success(result)
+        end
+
+        # We are pausing
+        correlation_id = nil
+        correlation_id = step_config.correlation_id_block.call(@context) if step_config.correlation_id_block
+
+        # Store current step as the one we are paused at
+        @context.current_step = step_config.name
+
+        RubyReactor::InterruptResult.new(
+          execution_id: @context.context_id,
+          correlation_id: correlation_id,
+          intermediate_results: @context.intermediate_results
+        )
+      end
+
       def configuration
         RubyReactor::Configuration.instance
       end

data/lib/ruby_reactor/executor.rb

@@ -40,24 +40,49 @@ module RubyReactor
       input_validator = InputValidator.new(@reactor_class, @context)
       input_validator.validate!
 
+      save_context
+
       graph_manager = GraphManager.new(@reactor_class, @dependency_graph, @context)
       graph_manager.build_and_validate!
+      graph_manager.mark_completed_steps_from_context
 
       @result = @step_executor.execute_all_steps
+      update_context_status(@result)
+      handle_interrupt(@result) if @result.is_a?(RubyReactor::InterruptResult)
+      @result
     rescue StandardError => e
       @result = @result_handler.handle_execution_error(e)
+      update_context_status(@result)
+      @result
+    ensure
+      save_context
     end
 
     def resume_execution
       prepare_for_resume
+      save_context
 
-      if @context.current_step
-        execute_current_step_and_continue
-      else
-        execute_remaining_steps
-      end
+      @result = if @context.current_step
+                  execute_current_step_and_continue
+                else
+                  execute_remaining_steps
+                end
+
+      update_context_status(@result)
+
+      handle_interrupt(@result) if @result.is_a?(RubyReactor::InterruptResult)
+
+      @result
     rescue StandardError => e
       handle_resume_error(e)
+      update_context_status(@result)
+      @result
+    ensure
+      save_context
+    end
+
+    def undo_all
+      @compensation_manager.rollback_completed_steps
     end
 
     def undo_stack
@@ -72,8 +97,45 @@ module RubyReactor
       @context.execution_trace
     end
 
+    def save_context
+      storage = RubyReactor::Configuration.instance.storage_adapter
+      reactor_class_name = @reactor_class.name || "AnonymousReactor-#{@reactor_class.object_id}"
+
+      # Serialize context
+      serialized_context = ContextSerializer.serialize(@context)
+      storage.store_context(@context.context_id, serialized_context, reactor_class_name)
+    end
+
     private
 
+    def update_context_status(result)
+      return unless result
+
+      case result
+      when RubyReactor::AsyncResult
+        @context.status = :running
+      when RubyReactor::Success
+        @context.status = :completed
+      when RubyReactor::Failure
+        @context.status = :failed
+        @context.failure_reason = {
+          message: result.error.is_a?(Exception) ? result.error.message : result.error.to_s,
+          step_name: result.step_name,
+          inputs: result.inputs,
+          backtrace: result.backtrace,
+          reactor_name: result.reactor_name,
+          step_arguments: result.step_arguments,
+          exception_class: result.exception_class,
+          file_path: result.file_path,
+          line_number: result.line_number,
+          code_snippet: result.code_snippet,
+          validation_errors: result.validation_errors
+        }
+      when RubyReactor::InterruptResult
+        @context.status = :paused
+      end
+    end
+
     def prepare_for_resume
       # Build dependency graph and mark completed steps
       graph_manager = GraphManager.new(@reactor_class, @dependency_graph, @context)
@@ -85,6 +147,9 @@ module RubyReactor
       step_config = @reactor_class.steps[@context.current_step]
       return RubyReactor::Failure("Step '#{@context.current_step}' not found in reactor") unless step_config
 
+      # If current step is already in intermediate_results, skip directly to execute_all_steps
+      return @step_executor.execute_all_steps if @context.intermediate_results.key?(@context.current_step.to_sym)
+
       # Use execute_step (not execute_step_with_retry) so that async steps can be handled properly in inline mode
       result = @step_executor.execute_step(step_config)
 
@@ -93,7 +158,7 @@ module RubyReactor
         @result = @step_executor.execute_all_steps
       else
         case result
-        when RetryQueuedResult, RubyReactor::Failure, RubyReactor::AsyncResult
+        when RetryQueuedResult, RubyReactor::Failure, RubyReactor::AsyncResult, RubyReactor::InterruptResult
           # Step was requeued, failed, or handed off to async - return the result
           @result = result
         when RubyReactor::Success
@@ -110,14 +175,22 @@ module RubyReactor
     end
 
     def handle_resume_error(error)
-      # Only handle errors that haven't already triggered compensation
-      # StepFailureError means compensation already happened, just convert to Failure
-      @result = if error.is_a?(Error::StepFailureError)
-                  RubyReactor.Failure(error.message)
-                else
-                  @result_handler.handle_execution_error(error)
-                end
+      @result = @result_handler.handle_execution_error(error)
       @result
     end
+
+    def handle_interrupt(interrupt_result)
+      save_context
+
+      # Store correlation ID mapping if present
+      return unless interrupt_result.correlation_id
+
+      storage = RubyReactor::Configuration.instance.storage_adapter
+      storage.store_correlation_id(
+        interrupt_result.correlation_id,
+        @context.context_id,
+        @reactor_class.name
+      )
+    end
   end
 end

data/lib/ruby_reactor/interrupt_result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  class InterruptResult
+    attr_reader :execution_id, :correlation_id, :status, :timeout_at, :intermediate_results, :error
+
+    def initialize(execution_id:, correlation_id: nil, timeout_at: nil, intermediate_results: {}, error: nil)
+      @execution_id = execution_id
+      @correlation_id = correlation_id
+      @status = :paused
+      @timeout_at = timeout_at
+      @intermediate_results = intermediate_results
+      @error = error
+    end
+
+    def paused?
+      true
+    end
+  end
+end

data/lib/ruby_reactor/map/collector.rb

@@ -5,61 +5,97 @@ module RubyReactor
     class Collector
       extend Helpers
 
-      # rubocop:disable Metrics/MethodLength
       def self.perform(arguments)
         arguments = arguments.transform_keys(&:to_sym)
-        parent_context_id = arguments[:parent_context_id]
         map_id = arguments[:map_id]
+        parent_context_id = arguments[:parent_context_id]
         parent_reactor_class_name = arguments[:parent_reactor_class_name]
         step_name = arguments[:step_name]
         strict_ordering = arguments[:strict_ordering]
+        # timeout = arguments[:timeout]
 
         storage = RubyReactor.configuration.storage_adapter
+        parent_context_data = storage.retrieve_context(parent_context_id, parent_reactor_class_name)
+        parent_context = RubyReactor::Context.deserialize_from_retry(parent_context_data)
+
+        # Check if all tasks are completed
+        metadata = storage.retrieve_map_metadata(map_id, parent_reactor_class_name)
+        total_count = metadata ? metadata["count"].to_i : 0
+
+        results_count = storage.count_map_results(map_id, parent_reactor_class_name)
+
+        # Not done yet, requeue or wait?
+        # Actually Collector currently assumes we only call it when we expect completion or check progress
+        # Since map_offset tracks dispatching progress and might exceed count due to batching reservation,
+        # we must strictly check against the total count of elements.
+        # Check for fail_fast failure FIRST
+        failed_context_id = storage.retrieve_map_failed_context_id(map_id, parent_reactor_class_name)
+        if failed_context_id
+          # Resolve the class of the mapped reactor to retrieve its context
+          reactor_class = resolve_reactor_class(metadata["reactor_class_info"])
 
-        # Retrieve parent context
-        parent_context = load_parent_context_from_storage(
-          parent_context_id,
+          failed_context_data = storage.retrieve_context(failed_context_id, reactor_class.name)
+
+          if failed_context_data
+            failed_context = RubyReactor::Context.deserialize_from_retry(failed_context_data)
+
+            # Resume parent execution (which marks step as failed)
+            resume_parent_execution(parent_context, step_name, RubyReactor::Failure(failed_context.failure_reason),
+                                    storage)
+            return
+          end
+        end
+
+        return if results_count < total_count
+
+        # Retrieve results lazily
+        results = RubyReactor::Map::ResultEnumerator.new(
+          map_id,
           parent_reactor_class_name,
-          storage
+          strict_ordering: strict_ordering
         )
 
-        # Retrieve results
-        serialized_results = storage.retrieve_map_results(map_id, parent_reactor_class_name,
-                                                          strict_ordering: strict_ordering)
+        # Apply collect block (or default collection)
+        step_config = parent_context.reactor_class.steps[step_name.to_sym]
 
-        results = serialized_results.map do |r|
-          if r.is_a?(Hash) && r.key?("_error")
-            RubyReactor::Failure(r["_error"])
-          else
-            RubyReactor::Success(r)
+        begin
+          final_result = apply_collect_block(results, step_config)
+
+          if final_result.failure?
+            # Optionally log failure internally or just rely on context status update
           end
+        rescue StandardError => e
+          final_result = RubyReactor::Failure(e)
         end
 
-        # Get step config to check for collect block and other options
-        parent_class = Object.const_get(parent_reactor_class_name)
-        step_config = parent_class.steps[step_name.to_sym]
+        # Resume parent execution
+        resume_parent_execution(parent_context, step_name, final_result, storage)
+      rescue StandardError => e
+        puts "COLLECTOR CRASH: #{e.message}"
+        puts e.backtrace
+        raise e
+      end
 
-        collect_block = step_config.arguments[:collect_block][:source].value
+      def self.apply_collect_block(results, step_config)
+        collect_block = step_config.arguments[:collect_block][:source].value if step_config.arguments[:collect_block]
         # TODO: Check allow_partial_failure option
 
-        final_result = if collect_block
-                         begin
-                           # Pass all results (Success and Failure) to collect block
-                           collected = collect_block.call(results)
-                           RubyReactor::Success(collected)
-                         rescue StandardError => e
-                           RubyReactor::Failure(e)
-                         end
-                       else
-                         # Default behavior: fail if any failure
-                         first_failure = results.find(&:failure?)
-                         first_failure || RubyReactor::Success(results.map(&:value))
-                       end
-
-        # Resume execution
-        resume_parent_execution(parent_context, step_name, final_result, storage)
+        if collect_block
+          begin
+            # Pass Enumerator to collect block
+            collected = collect_block.call(results)
+            RubyReactor::Success(collected)
+          rescue StandardError => e
+            puts "COLLECTOR INNER EXCEPTION: #{e.message}"
+            puts e.backtrace
+            RubyReactor::Failure(e)
+          end
+        else
+          # Default behavior: Return Success(Enumerator).
+          # Logic for checking failures is deferred to the consumer of the enumerator.
+          RubyReactor::Success(results)
+        end
       end
-      # rubocop:enable Metrics/MethodLength
     end
   end
 end