ruby_reactor 0.1.0

data/lib/ruby_reactor/sidekiq_workers/map_element_worker.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module SidekiqWorkers
+    class MapElementWorker
+      include ::Sidekiq::Worker
+
+      def perform(arguments)
+        RubyReactor::Map::ElementExecutor.perform(arguments)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/sidekiq_workers/map_execution_worker.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module RubyReactor
+  module SidekiqWorkers
+    class MapExecutionWorker
+      include ::Sidekiq::Worker
+
+      def perform(arguments)
+        RubyReactor::Map::Execution.perform(arguments)
+      end
+    end
+  end
+end

data/lib/ruby_reactor/sidekiq_workers/worker.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module RubyReactor
+  module SidekiqWorkers
+    # Sidekiq worker for executing RubyReactor reactors asynchronously
+    # with non-blocking retry capabilities
+    class Worker
+      include ::Sidekiq::Worker
+
+      # Enable Sidekiq retries for infrastructure failures only
+      sidekiq_options retry: RubyReactor.configuration.sidekiq_retry_count, dead: false,
+                      queue: RubyReactor.configuration.sidekiq_queue
+
+      sidekiq_retries_exhausted do |_, exception|
+        # Handle infrastructure failures (network, Redis, etc.)
+      end
+
+      def perform(serialized_context, reactor_class_name = nil)
+        context = ContextSerializer.deserialize(serialized_context)
+
+        # If reactor_class_name is provided, use it to get the reactor class
+        # This handles cases where the class can't be found via const_get
+        if reactor_class_name && context.reactor_class.nil?
+          begin
+            context.reactor_class = Object.const_get(reactor_class_name)
+          rescue NameError
+            # If not found, try to find it in the current namespace
+            # This is a fallback for test environments
+            context.reactor_class = reactor_class_name.constantize if reactor_class_name.respond_to?(:constantize)
+          end
+        end
+
+        # Mark that we're executing inline to prevent nested async calls
+        context.inline_async_execution = true
+
+        # Resume execution from the failed step
+        executor = Executor.new(context.reactor_class, {}, context)
+        executor.compensation_manager.undo_stack.concat(context.undo_stack)
+        executor.resume_execution
+
+        # Return the executor (which now has the result stored in it)
+        executor
+      end
+
+      private
+
+      def log_infrastructure_failure(msg, exception)
+        ::Sidekiq.logger.error("RubyReactor infrastructure failure: #{exception.message}")
+        ::Sidekiq.logger.error("Job details: #{msg.inspect}")
+      end
+    end
+  end
+end

data/lib/ruby_reactor/step/compose_step.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Step
+    class ComposeStep
+      include RubyReactor::Step
+
+      attr_reader :composed_reactor_class, :argument_mappings
+
+      def initialize(composed_reactor_class, argument_mappings = {})
+        @composed_reactor_class = composed_reactor_class
+        @argument_mappings = argument_mappings
+      end
+
+      def self.run(arguments, context)
+        step_name = context.current_step
+        composed_data = context.composed_contexts[step_name]
+        child_context = prepare_child_context(arguments, context, composed_data)
+
+        # Store the child context in composed_contexts BEFORE execution
+        store_child_context(context, step_name, child_context)
+
+        # Execute the composed reactor
+        result = execute_child_reactor(arguments[:composed_reactor_class], child_context, composed_data)
+
+        # Update the stored context
+        store_child_context(context, step_name, child_context)
+
+        handle_execution_result(result)
+      end
+
+      def self.compensate(_reason, _arguments, _context)
+        # TODO: Implement proper compensation for composed reactors
+        # This requires tracking the execution state of the composed reactor
+        # and being able to trigger compensation on its completed steps.
+        # For now, we assume the composed reactor handles its own compensation
+        # or that compensation is not needed for composed steps.
+
+        RubyReactor.Success()
+      end
+
+      class << self
+        private
+
+        def build_composed_inputs(mappings, context)
+          inputs = {}
+
+          mappings.each do |composed_input_name, source|
+            value = source.resolve(context)
+            inputs[composed_input_name] = value
+          end
+
+          inputs
+        end
+
+        def prepare_child_context(arguments, context, composed_data)
+          child_context = composed_data ? composed_data[:context] : nil
+
+          unless child_context
+            composed_inputs = build_composed_inputs(arguments[:argument_mappings] || {}, context)
+            child_context = RubyReactor::Context.new(composed_inputs, arguments[:composed_reactor_class])
+          end
+
+          link_contexts(child_context, context)
+          child_context
+        end
+
+        def link_contexts(child_context, parent_context)
+          child_context.parent_context = parent_context
+          child_context.root_context = parent_context.root_context || parent_context
+          child_context.test_mode = parent_context.test_mode
+          child_context.inline_async_execution = parent_context.inline_async_execution
+        end
+
+        def store_child_context(context, step_name, child_context)
+          context.composed_contexts[step_name] = {
+            name: step_name,
+            type: :composed,
+            context: child_context
+          }
+        end
+
+        def execute_child_reactor(composed_reactor, child_context, composed_data)
+          executor = RubyReactor::Executor.new(composed_reactor, {}, child_context)
+
+          if composed_data && child_context.current_step
+            executor.resume_execution
+          else
+            executor.execute
+          end
+
+          executor.result
+        end
+
+        def handle_execution_result(result)
+          return result if result.is_a?(RubyReactor::AsyncResult) || result.is_a?(RubyReactor::RetryQueuedResult)
+
+          if result.success?
+            RubyReactor.Success(result.value)
+          else
+            RubyReactor.Failure(result.error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/step/map_step.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Step
+    class MapStep
+      include RubyReactor::Step
+
+      def self.run(arguments, context)
+        return RubyReactor::Failure("Map source cannot be nil") if arguments[:source].nil?
+
+        # Initialize map state in context if not present
+        context.map_operations ||= {}
+
+        if should_run_async?(arguments, context)
+          run_async(arguments, context, context.current_step)
+        else
+          run_inline(arguments, context)
+        end
+      end
+
+      def self.compensate(_reason, _arguments, _context)
+        # TODO: Implement compensation for map steps
+        RubyReactor.Success()
+      end
+
+      class << self
+        def build_mapped_inputs(mappings, context, element)
+          inputs = {}
+
+          mappings.each do |mapped_input_name, source|
+            value = if source.is_a?(RubyReactor::Template::Element)
+                      # Handle element reference
+                      # For now assuming element() refers to the current map's element
+                      # In nested maps, we might need to check the name, but for now simple case
+                      resolve_element(source, element)
+                    else
+                      source.resolve(context)
+                    end
+            inputs[mapped_input_name] = value
+          end
+
+          inputs
+        end
+
+        def resolve_element(template_element, current_element)
+          # If path is provided, extract it
+          if template_element.path
+            extract_path(current_element, template_element.path)
+          else
+            current_element
+          end
+        end
+
+        private
+
+        def should_run_async?(arguments, context)
+          arguments[:async] && !context.inline_async_execution
+        end
+
+        def run_inline(arguments, context)
+          results = execute_inline_map(arguments, context)
+          return results if results.is_a?(RubyReactor::Failure)
+
+          process_results(results, arguments[:collect_block], arguments[:fail_fast])
+        end
+
+        def execute_inline_map(arguments, context)
+          results = []
+          fail_fast = arguments[:fail_fast].nil? || arguments[:fail_fast]
+
+          arguments[:source].each do |element|
+            result = execute_single_element(element, arguments, context)
+
+            if fail_fast && result.failure?
+              return result # Stop immediately on first failure
+            end
+
+            # When fail_fast is false, store Result objects; when true, store values
+            results << (fail_fast ? result.value : result)
+          end
+
+          results
+        end
+
+        def execute_single_element(element, arguments, context)
+          mapped_inputs = build_mapped_inputs(arguments[:argument_mappings] || {}, context, element)
+          child_context = RubyReactor::Context.new(mapped_inputs, arguments[:mapped_reactor_class])
+
+          link_contexts(child_context, context)
+
+          executor = RubyReactor::Executor.new(arguments[:mapped_reactor_class], {}, child_context)
+          executor.execute
+          executor.result
+        end
+
+        def link_contexts(child_context, parent_context)
+          child_context.parent_context = parent_context
+          child_context.root_context = parent_context.root_context || parent_context
+          child_context.test_mode = parent_context.test_mode
+          child_context.inline_async_execution = parent_context.inline_async_execution
+        end
+
+        def process_results(results, collect_block, fail_fast = true)
+          if collect_block
+            begin
+              # Collect block receives Result objects when fail_fast is false, values when true
+              RubyReactor::Success(collect_block.call(results))
+            rescue StandardError => e
+              RubyReactor::Failure(e)
+            end
+          elsif fail_fast
+            # Default behavior when no collect block
+            # Current behavior: results are already values
+            RubyReactor::Success(results)
+          else
+            # New behavior: extract successful values only
+            successes = results.select(&:success?).map(&:value)
+            RubyReactor::Success(successes)
+          end
+        end
+
+        def extract_path(value, path)
+          if path.is_a?(Symbol) && value.respond_to?(:[])
+            value[path]
+          elsif path.is_a?(String)
+            path.split(".").reduce(value) { |v, key| v&.send(:[], key) }
+          elsif path.is_a?(Array)
+            path.reduce(value) { |v, key| v&.send(:[], key) }
+          elsif value.respond_to?(path)
+            value.send(path)
+          end
+        end
+
+        def run_async(arguments, context, step_name)
+          map_id = "#{context.context_id}:#{step_name}"
+          context.map_operations[step_name.to_s] = map_id
+          prepare_async_execution(context, map_id, arguments[:source].count)
+
+          reactor_class_info = build_reactor_class_info(arguments[:mapped_reactor_class], context, step_name)
+
+          job_id = if arguments[:batch_size]
+                     storage = RubyReactor.configuration.storage_adapter
+                     storage.set_last_queued_index(map_id, arguments[:batch_size] - 1, context.reactor_class.name)
+                     queue_fan_out(
+                       map_id: map_id, arguments: arguments, context: context,
+                       reactor_class_info: reactor_class_info, step_name: step_name,
+                       limit: arguments[:batch_size]
+                     )
+                   else
+                     queue_single_worker(map_id: map_id, arguments: arguments, context: context,
+                                         reactor_class_info: reactor_class_info, step_name: step_name)
+                   end
+
+          RubyReactor::AsyncResult.new(job_id: job_id, intermediate_results: context.intermediate_results)
+        end
+
+        def prepare_async_execution(context, map_id, count)
+          storage = RubyReactor.configuration.storage_adapter
+          serialized_context = ContextSerializer.serialize(context)
+          storage.store_context(context.context_id, serialized_context, context.reactor_class.name)
+          storage.set_map_counter(map_id, count, context.reactor_class.name)
+        end
+
+        def build_reactor_class_info(mapped_reactor_class, context, step_name)
+          if mapped_reactor_class.respond_to?(:name)
+            { "type" => "class", "name" => mapped_reactor_class.name }
+          else
+            { "type" => "inline", "parent" => context.reactor_class.name, "step" => step_name.to_s }
+          end
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def queue_fan_out(map_id:, arguments:, context:, reactor_class_info:, step_name:, limit: nil)
+          # rubocop:enable Metrics/ParameterLists
+          storage = RubyReactor.configuration.storage_adapter
+          storage.initialize_map_operation(
+            map_id, arguments[:source].count, context.reactor_class.name,
+            strict_ordering: arguments[:strict_ordering], reactor_class_info: reactor_class_info
+          )
+
+          limit ||= arguments[:source].count
+          first_job_id = nil
+          arguments[:source].each_with_index do |element, index|
+            break if index >= limit
+
+            job_id = queue_map_element(
+              map_id: map_id, element: element, index: index, arguments: arguments,
+              context: context, reactor_class_info: reactor_class_info, step_name: step_name
+            )
+            first_job_id ||= job_id
+          end
+
+          queue_collector(map_id, context, step_name, arguments[:strict_ordering])
+          first_job_id
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def queue_map_element(map_id:, element:, index:, arguments:, context:, reactor_class_info:, step_name:)
+          mapped_inputs = build_mapped_inputs(arguments[:argument_mappings] || {}, context, element)
+          serialized_inputs = ContextSerializer.serialize_value(mapped_inputs)
+
+          RubyReactor.configuration.async_router.perform_map_element_async(
+            map_id: map_id, element_id: "#{map_id}:#{index}", index: index,
+            serialized_inputs: serialized_inputs, reactor_class_info: reactor_class_info,
+            strict_ordering: arguments[:strict_ordering], parent_context_id: context.context_id,
+            parent_reactor_class_name: context.reactor_class.name, step_name: step_name.to_s,
+            batch_size: arguments[:batch_size]
+          )
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        def queue_collector(map_id, context, step_name, strict_ordering)
+          RubyReactor.configuration.async_router.perform_map_collection_async(
+            parent_context_id: context.context_id, map_id: map_id,
+            parent_reactor_class_name: context.reactor_class.name, step_name: step_name.to_s,
+            strict_ordering: strict_ordering, timeout: 3600
+          )
+        end
+
+        def queue_single_worker(map_id:, arguments:, context:, reactor_class_info:, step_name:)
+          inputs = { source: arguments[:source], mappings: arguments[:argument_mappings] || {} }
+          serialized_inputs = ContextSerializer.serialize_value(inputs)
+
+          RubyReactor.configuration.async_router.perform_map_execution_async(
+            map_id: map_id, serialized_inputs: serialized_inputs,
+            reactor_class_info: reactor_class_info, strict_ordering: arguments[:strict_ordering],
+            parent_context_id: context.context_id, parent_reactor_class_name: context.reactor_class.name,
+            step_name: step_name.to_s
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_reactor/step.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Step
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # rubocop:disable Naming/MethodName
+      def Success(value = nil)
+        RubyReactor::Success(value)
+      end
+
+      def Failure(error = nil)
+        RubyReactor::Failure(error)
+      end
+      # rubocop:enable Naming/MethodName
+
+      def run(arguments, context)
+        raise NotImplementedError, "#{self} must implement .run method"
+      end
+
+      def compensate(_reason, _arguments, _context)
+        RubyReactor.Success() # Default: accept failure and continue rollback
+      end
+
+      def undo(_result, _arguments, _context)
+        RubyReactor.Success() # Default: no-op undo
+      end
+    end
+  end
+end

data/lib/ruby_reactor/storage/adapter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Storage
+    class Adapter
+      def store_context(context_id, serialized_context, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def retrieve_context(context_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def store_map_result(map_id, index, serialized_result, reactor_class_name, strict_ordering: true)
+        raise NotImplementedError
+      end
+
+      def retrieve_map_results(map_id, reactor_class_name, strict_ordering: true)
+        raise NotImplementedError
+      end
+
+      def set_map_counter(map_id, count, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def initialize_map_operation(map_id, count, reactor_class_info:, strict_ordering: true)
+        raise NotImplementedError
+      end
+
+      def increment_map_counter(map_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def decrement_map_counter(map_id, reactor_class_name)
+        raise NotImplementedError
+      end
+
+      def subscribe(channel, &block)
+        raise NotImplementedError
+      end
+
+      def publish(channel, message)
+        raise NotImplementedError
+      end
+
+      def expire(key, seconds)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/ruby_reactor/storage/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Storage
+    class Configuration
+      attr_accessor :adapter, :redis_url, :redis_options
+
+      def initialize
+        @adapter = :redis
+        @redis_url = "redis://localhost:6379/0"
+        @redis_options = {}
+      end
+    end
+  end
+end

data/lib/ruby_reactor/storage/redis_adapter.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "redis"
+require "json"
+
+module RubyReactor
+  module Storage
+    class RedisAdapter < Adapter
+      def initialize(redis_config)
+        super()
+        @redis = Redis.new(redis_config)
+      end
+
+      def store_context(context_id, serialized_context, reactor_class_name)
+        key = context_key(context_id, reactor_class_name)
+        # Use JSON.SET for efficient storage and retrieval
+        @redis.call("JSON.SET", key, ".", serialized_context)
+        @redis.expire(key, 86_400) # 24h TTL
+      end
+
+      def retrieve_context(context_id, reactor_class_name)
+        key = context_key(context_id, reactor_class_name)
+        json = @redis.call("JSON.GET", key)
+        return nil unless json
+
+        JSON.parse(json)
+      end
+
+      def store_map_result(map_id, index, serialized_result, reactor_class_name, strict_ordering: true)
+        key = map_results_key(map_id, reactor_class_name)
+
+        if strict_ordering
+          # Use Hash for strict ordering by index
+          # HSET key index serialized_result
+          @redis.hset(key, index.to_s, serialized_result.to_json)
+        else
+          # Loose ordering: just push to list
+          @redis.rpush(key, serialized_result.to_json)
+        end
+
+        @redis.expire(key, 86_400)
+      end
+
+      def retrieve_map_results(map_id, reactor_class_name, strict_ordering: true)
+        key = map_results_key(map_id, reactor_class_name)
+
+        if strict_ordering
+          results = @redis.hgetall(key)
+          # Sort by index (key)
+          results.keys.sort_by(&:to_i).map { |k| JSON.parse(results[k]) }
+        else
+          results = @redis.lrange(key, 0, -1)
+          results.map { |r| JSON.parse(r) }
+        end
+      end
+
+      def set_map_counter(map_id, count, reactor_class_name)
+        key = map_counter_key(map_id, reactor_class_name)
+        @redis.set(key, count)
+        @redis.expire(key, 86_400)
+      end
+
+      def initialize_map_operation(map_id, count, parent_reactor_class_name, reactor_class_info:, strict_ordering: true)
+        # Ensure counter is set
+        set_map_counter(map_id, count, parent_reactor_class_name)
+
+        # Store metadata
+        key = "reactor:#{parent_reactor_class_name}:map:#{map_id}:metadata"
+        metadata = {
+          count: count,
+          strict_ordering: strict_ordering,
+          reactor_class_info: reactor_class_info,
+          created_at: Time.now.to_i
+        }
+        @redis.call("JSON.SET", key, ".", metadata.to_json)
+        @redis.expire(key, 86_400)
+      end
+
+      def retrieve_map_metadata(map_id, reactor_class_name)
+        key = "reactor:#{reactor_class_name}:map:#{map_id}:metadata"
+        json = @redis.call("JSON.GET", key)
+        return nil unless json
+
+        JSON.parse(json)
+      end
+
+      def increment_map_counter(map_id, reactor_class_name)
+        key = map_counter_key(map_id, reactor_class_name)
+        @redis.incr(key)
+        @redis.expire(key, 86_400)
+      end
+
+      def decrement_map_counter(map_id, reactor_class_name)
+        key = map_counter_key(map_id, reactor_class_name)
+        @redis.decr(key)
+      end
+
+      def set_last_queued_index(map_id, index, reactor_class_name)
+        key = map_last_queued_index_key(map_id, reactor_class_name)
+        @redis.set(key, index)
+        @redis.expire(key, 86_400)
+      end
+
+      def increment_last_queued_index(map_id, reactor_class_name)
+        key = map_last_queued_index_key(map_id, reactor_class_name)
+        @redis.incr(key)
+      end
+
+      def subscribe(channel, &block)
+        @redis.subscribe(channel, &block)
+      end
+
+      def publish(channel, message)
+        @redis.publish(channel, message)
+      end
+
+      def expire(key, seconds)
+        @redis.expire(key, seconds)
+      end
+
+      private
+
+      def context_key(context_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:context:#{context_id}"
+      end
+
+      def map_results_key(map_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:map:#{map_id}:results"
+      end
+
+      def map_counter_key(map_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:map:#{map_id}:counter"
+      end
+
+      def map_last_queued_index_key(map_id, reactor_class_name)
+        "reactor:#{reactor_class_name}:map:#{map_id}:last_queued_index"
+      end
+    end
+  end
+end

data/lib/ruby_reactor/template/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module Template
+    class Base
+      def resolve(context)
+        raise NotImplementedError, "Subclasses must implement #resolve"
+      end
+
+      def inspect
+        "#<#{self.class.name}>"
+      end
+    end
+  end
+end