igniter 0.2.0 → 0.3.0

data/lib/igniter/runtime/resolver.rb

@@ -9,8 +9,8 @@ module Igniter
 
       def resolve(node_name)
         node = @execution.compiled_graph.fetch_node(node_name)
-        cached = @execution.cache.fetch(node.name)
-        return cached if cached && !cached.stale?
+        resolution_status, cached = @execution.cache.begin_resolution(node)
+        return cached if resolution_status == :cached
 
         @execution.events.emit(:node_started, node: node, status: :running)
 
@@ -21,17 +21,30 @@ module Igniter
                   resolve_compute(node)
                 when :composition
                   resolve_composition(node)
+                when :branch
+                  resolve_branch(node)
+                when :collection
+                  resolve_collection(node)
                 else
                   raise ResolutionError, "Unsupported node kind: #{node.kind}"
                 end
 
         @execution.cache.write(state)
-        @execution.events.emit(
-          state.failed? ? :node_failed : :node_succeeded,
+        emit_resolution_event(node, state)
+        state
+      rescue PendingDependencyError => e
+        state = NodeState.new(
           node: node,
-          status: state.status,
-          payload: success_payload(node, state)
+          status: :pending,
+          value: Runtime::DeferredResult.build(
+            token: e.deferred_result.token,
+            payload: e.deferred_result.payload,
+            source_node: e.deferred_result.source_node,
+            waiting_on: e.deferred_result.waiting_on || node.name
+          )
         )
+        @execution.cache.write(state)
+        @execution.events.emit(:node_pending, node: node, status: :pending, payload: pending_payload(state))
         state
       rescue StandardError => e
         state = NodeState.new(node: node, status: :failed, error: normalize_error(e, node))
@@ -48,13 +61,13 @@ module Igniter
 
       def resolve_compute(node)
         dependencies = node.dependencies.each_with_object({}) do |dependency_name, memo|
-          dependency_state = resolve(dependency_name)
-          raise dependency_state.error if dependency_state.failed?
-
-          memo[dependency_name] = dependency_state.value
+          memo[dependency_name] = resolve_dependency_value(dependency_name)
         end
 
         value = call_compute(node.callable, dependencies)
+        return NodeState.new(node: node, status: :pending, value: normalize_deferred_result(value, node)) if deferred_result?(value)
+        value = normalize_guard_value(node, value)
+
         NodeState.new(node: node, status: :succeeded, value: value)
       end
 
@@ -62,8 +75,28 @@ module Igniter
         case callable
         when Proc
           callable.call(**dependencies)
+        when Class
+          call_compute_class(callable, dependencies)
         when Symbol, String
           @execution.contract_instance.public_send(callable.to_sym, **dependencies)
+        else
+          call_compute_object(callable, dependencies)
+        end
+      end
+
+      def call_compute_class(callable, dependencies)
+        if callable <= Igniter::Executor
+          callable.new(execution: @execution, contract: @execution.contract_instance).call(**dependencies)
+        elsif callable.respond_to?(:call)
+          callable.call(**dependencies)
+        else
+          raise ResolutionError, "Unsupported callable: #{callable}"
+        end
+      end
+
+      def call_compute_object(callable, dependencies)
+        if callable.respond_to?(:call)
+          callable.call(**dependencies)
         else
           raise ResolutionError, "Unsupported callable: #{callable.class}"
         end
@@ -71,10 +104,7 @@ module Igniter
 
       def resolve_composition(node)
         child_inputs = node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
-          dependency_state = resolve(dependency_name)
-          raise dependency_state.error if dependency_state.failed?
-
-          memo[child_input_name] = dependency_state.value
+          memo[child_input_name] = resolve_dependency_value(dependency_name)
         end
 
         child_contract = node.contract_class.new(child_inputs)
@@ -85,8 +115,162 @@ module Igniter
         NodeState.new(node: node, status: :succeeded, value: child_contract.result)
       end
 
+      def resolve_branch(node)
+        selector_value = resolve_dependency_value(node.selector_dependency)
+        selected_case = node.cases.find { |entry| entry[:match] == selector_value }
+        selected_contract = selected_case ? selected_case[:contract] : node.default_contract
+        matched_case = selected_case ? selected_case[:match] : :default
+
+        raise BranchSelectionError, "Branch '#{node.name}' has no matching case and no default" unless selected_contract
+
+        child_inputs = node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
+          memo[child_input_name] = resolve_dependency_value(dependency_name)
+        end
+
+        @execution.events.emit(
+          :branch_selected,
+          node: node,
+          status: :succeeded,
+          payload: {
+            selector: node.selector_dependency,
+            selector_value: selector_value,
+            matched_case: matched_case,
+            selected_contract: selected_contract.name || "AnonymousContract"
+          }
+        )
+
+        child_contract = selected_contract.new(child_inputs)
+        child_contract.resolve_all
+        child_error = child_contract.result.errors.values.first
+        raise child_error if child_error
+
+        NodeState.new(node: node, status: :succeeded, value: child_contract.result)
+      end
+
+      def resolve_collection(node)
+        items = resolve_dependency_value(node.source_dependency)
+        normalized_items = normalize_collection_items(node, items)
+        collection_items = {}
+
+        normalized_items.each do |item_inputs|
+          item_key = extract_collection_key(node, item_inputs)
+          emit_collection_item_event(:collection_item_started, node, item_key, item_inputs: item_inputs)
+          child_contract = node.contract_class.new(item_inputs)
+          begin
+            child_contract.resolve_all
+          rescue Igniter::Error
+            nil
+          end
+          child_error = child_contract.execution.cache.values.find(&:failed?)&.error
+
+          if child_error
+            collection_items[item_key] = Runtime::CollectionResult::Item.new(
+              key: item_key,
+              status: :failed,
+              error: child_error
+            )
+            emit_collection_item_event(
+              :collection_item_failed,
+              node,
+              item_key,
+              error: child_error.message,
+              error_type: child_error.class.name,
+              child_execution_id: child_contract.execution.events.execution_id
+            )
+            raise child_error if node.mode == :fail_fast
+          else
+            collection_items[item_key] = Runtime::CollectionResult::Item.new(
+              key: item_key,
+              status: :succeeded,
+              result: child_contract.result
+            )
+            emit_collection_item_event(
+              :collection_item_succeeded,
+              node,
+              item_key,
+              child_execution_id: child_contract.execution.events.execution_id
+            )
+          end
+        end
+
+        NodeState.new(
+          node: node,
+          status: :succeeded,
+          value: Runtime::CollectionResult.new(items: collection_items, mode: node.mode)
+        )
+      end
+
+      def resolve_dependency_value(dependency_name)
+        if @execution.compiled_graph.node?(dependency_name)
+          dependency_state = resolve(dependency_name)
+          raise dependency_state.error if dependency_state.failed?
+          raise PendingDependencyError.new(dependency_state.value, context: pending_context(dependency_state.node)) if dependency_state.pending?
+
+          dependency_state.value
+        elsif @execution.compiled_graph.outputs_by_name.key?(dependency_name.to_sym)
+          output = @execution.compiled_graph.fetch_output(dependency_name)
+          value = @execution.send(:resolve_exported_output, output)
+          raise PendingDependencyError.new(value) if deferred_result?(value)
+
+          value
+        else
+          raise ResolutionError, "Unknown dependency: #{dependency_name}"
+        end
+      end
+
+      def deferred_result?(value)
+        value.is_a?(Runtime::DeferredResult)
+      end
+
+      def normalize_deferred_result(value, node)
+        Runtime::DeferredResult.build(
+          token: value.token,
+          payload: value.payload,
+          source_node: value.source_node || node.name,
+          waiting_on: value.waiting_on
+        )
+      end
+
+      def emit_resolution_event(node, state)
+        event_type =
+          if state.failed?
+            :node_failed
+          elsif state.pending?
+            :node_pending
+          else
+            :node_succeeded
+          end
+
+        payload = state.pending? ? pending_payload(state) : success_payload(node, state)
+        @execution.events.emit(event_type, node: node, status: state.status, payload: payload)
+      end
+
+      def emit_collection_item_event(type, node, item_key, payload = {})
+        @execution.events.emit(
+          type,
+          node: node,
+          payload: payload.merge(item_key: item_key)
+        )
+      end
+
+      def pending_payload(state)
+        return {} unless state.value.is_a?(Runtime::DeferredResult)
+
+        state.value.to_h
+      end
+
+      def pending_context(node)
+        {
+          graph: @execution.compiled_graph.name,
+          node_id: node.id,
+          node_name: node.name,
+          node_path: node.path,
+          source_location: node.source_location
+        }
+      end
+
       def success_payload(node, state)
-        return {} unless node.kind == :composition
+        return {} unless %i[composition branch].include?(node.kind)
         return {} unless state.value.is_a?(Igniter::Runtime::Result)
 
         {
@@ -109,6 +293,76 @@ module Igniter
           }
         )
       end
+
+      def normalize_guard_value(node, value)
+        return value unless node.respond_to?(:guard?) && node.guard?
+        return true if value
+
+        raise ResolutionError.new(
+          node.metadata[:guard_message] || "Guard '#{node.name}' failed",
+          context: {
+            graph: @execution.compiled_graph.name,
+            node_id: node.id,
+            node_name: node.name,
+            node_path: node.path,
+            source_location: node.source_location
+          }
+        )
+      end
+
+      def normalize_collection_items(node, items)
+        unless items.is_a?(Array)
+          raise CollectionInputError.new(
+            "Collection '#{node.name}' expects an array, got #{items.class}",
+            context: collection_context(node)
+          )
+        end
+
+        items.each do |item|
+          next if item.is_a?(Hash)
+
+          raise CollectionInputError.new(
+            "Collection '#{node.name}' expects item hashes, got #{item.class}",
+            context: collection_context(node)
+          )
+        end
+
+        ensure_unique_collection_keys!(node, items)
+        items.map { |item| item.transform_keys(&:to_sym) }
+      end
+
+      def extract_collection_key(node, item_inputs)
+        item_inputs.fetch(node.key_name)
+      rescue KeyError
+        raise CollectionKeyError.new(
+          "Collection '#{node.name}' item is missing key '#{node.key_name}'",
+          context: collection_context(node)
+        )
+      end
+
+      def ensure_unique_collection_keys!(node, items)
+        keys = items.map do |item|
+          item.fetch(node.key_name) { raise CollectionKeyError.new("Collection '#{node.name}' item is missing key '#{node.key_name}'", context: collection_context(node)) }
+        end
+
+        duplicates = keys.group_by(&:itself).select { |_key, entries| entries.size > 1 }.keys
+        return if duplicates.empty?
+
+        raise CollectionKeyError.new(
+          "Collection '#{node.name}' has duplicate keys: #{duplicates.join(', ')}",
+          context: collection_context(node)
+        )
+      end
+
+      def collection_context(node)
+        {
+          graph: @execution.compiled_graph.name,
+          node_id: node.id,
+          node_name: node.name,
+          node_path: node.path,
+          source_location: node.source_location
+        }
+      end
     end
   end
 end

data/lib/igniter/runtime/result.rb

@@ -18,7 +18,7 @@ module Igniter
 
       def success?
         @execution.resolve_all
-        !failed?
+        !failed? && !pending?
       end
 
       def failed?
@@ -26,6 +26,11 @@ module Igniter
         @execution.cache.values.any?(&:failed?)
       end
 
+      def pending?
+        @execution.resolve_all
+        @execution.cache.values.any?(&:pending?)
+      end
+
       def errors
         @execution.resolve_all
         @execution.cache.values.each_with_object({}) do |state, memo|
@@ -52,8 +57,9 @@ module Igniter
           graph: @execution.compiled_graph.name,
           execution_id: @execution.events.execution_id,
           outputs: to_h,
-          success: !failed?,
+          success: !failed? && !pending?,
           failed: failed?,
+          pending: pending?,
           errors: serialize_errors(errors),
           states: states
         }
@@ -73,6 +79,8 @@ module Igniter
         case value
         when Result
           value.as_json
+        when CollectionResult
+          value.as_json
         when Array
           value.map { |item| serialize_value(item) }
         else
@@ -82,8 +90,12 @@ module Igniter
 
       def serialize_output_value(value)
         case value
+        when DeferredResult
+          value.as_json
         when Result
           value.to_h
+        when CollectionResult
+          value.to_h
         when Array
           value.map { |item| serialize_output_value(item) }
         else

data/lib/igniter/runtime/runner_factory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class RunnerFactory
+      def self.build(strategy, execution, resolver:, max_workers: nil, store: nil)
+        case strategy.to_sym
+        when :inline
+          Runners::InlineRunner.new(execution, resolver: resolver, max_workers: max_workers)
+        when :store
+          Runners::StoreRunner.new(execution, resolver: resolver, store: store, max_workers: max_workers)
+        when :thread_pool
+          Runners::ThreadPoolRunner.new(execution, resolver: resolver, max_workers: max_workers)
+        else
+          raise CompileError, "Unknown execution runner strategy: #{strategy}"
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/runners/inline_runner.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    module Runners
+      class InlineRunner
+        def initialize(execution, resolver:, max_workers: nil)
+          @execution = execution
+          @resolver = resolver
+          @max_workers = max_workers
+        end
+
+        def run(node_names)
+          Array(node_names).each do |node_name|
+            @resolver.resolve(node_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/runners/store_runner.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    module Runners
+      class StoreRunner
+        def initialize(execution, resolver:, store:, max_workers: nil)
+          @execution = execution
+          @delegate = InlineRunner.new(execution, resolver: resolver, max_workers: max_workers)
+          @store = store
+        end
+
+        def run(node_names)
+          @delegate.run(node_names)
+        end
+
+        def persist!
+          return unless @store
+
+          if @execution.pending?
+            @store.save(@execution.snapshot(include_resolution: false))
+          else
+            @store.delete(@execution.events.execution_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/runners/thread_pool_runner.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Igniter
+  module Runtime
+    module Runners
+      class ThreadPoolRunner
+        def initialize(execution, resolver:, max_workers: nil)
+          @execution = execution
+          @resolver = resolver
+          @max_workers = [Integer(max_workers || 4), 1].max
+        end
+
+        def run(node_names)
+          queue = Queue.new
+          Array(node_names).each { |node_name| queue << node_name }
+          worker_count = [@max_workers, queue.size].min
+          return if worker_count.zero?
+
+          threads = worker_count.times.map do
+            Thread.new do
+              loop do
+                node_name = queue.pop(true)
+                @resolver.resolve(node_name)
+              rescue ThreadError
+                break
+              end
+            end
+          end
+
+          threads.each(&:join)
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/stores/active_record_store.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Runtime
+    module Stores
+      class ActiveRecordStore
+        def initialize(record_class:, execution_id_column: :execution_id, snapshot_column: :snapshot_json)
+          @record_class = record_class
+          @execution_id_column = execution_id_column.to_sym
+          @snapshot_column = snapshot_column.to_sym
+        end
+
+        def save(snapshot)
+          execution_id = snapshot[:execution_id] || snapshot["execution_id"]
+          record = @record_class.find_or_initialize_by(@execution_id_column => execution_id)
+          record.public_send(:"#{@snapshot_column}=", JSON.generate(snapshot))
+          record.save!
+          execution_id
+        end
+
+        def fetch(execution_id)
+          record = @record_class.find_by(@execution_id_column => execution_id)
+          raise Igniter::ResolutionError, "No execution snapshot found for '#{execution_id}'" unless record
+
+          JSON.parse(record.public_send(@snapshot_column))
+        end
+
+        def delete(execution_id)
+          record = @record_class.find_by(@execution_id_column => execution_id)
+          record&.destroy!
+        end
+
+        def exist?(execution_id)
+          !!@record_class.find_by(@execution_id_column => execution_id)
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/stores/file_store.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Igniter
+  module Runtime
+    module Stores
+      class FileStore
+        def initialize(root:)
+          @root = root
+          FileUtils.mkdir_p(@root)
+        end
+
+        def save(snapshot)
+          execution_id = snapshot[:execution_id] || snapshot["execution_id"]
+          File.write(path_for(execution_id), JSON.pretty_generate(snapshot))
+          execution_id
+        end
+
+        def fetch(execution_id)
+          JSON.parse(File.read(path_for(execution_id)))
+        rescue Errno::ENOENT
+          raise Igniter::ResolutionError, "No execution snapshot found for '#{execution_id}'"
+        end
+
+        def delete(execution_id)
+          FileUtils.rm_f(path_for(execution_id))
+        end
+
+        def exist?(execution_id)
+          File.exist?(path_for(execution_id))
+        end
+
+        private
+
+        def path_for(execution_id)
+          File.join(@root, "#{execution_id}.json")
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/stores/memory_store.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    module Stores
+      class MemoryStore
+        def initialize
+          @snapshots = {}
+          @mutex = Mutex.new
+        end
+
+        def save(snapshot)
+          execution_id = snapshot[:execution_id] || snapshot["execution_id"]
+          @mutex.synchronize { @snapshots[execution_id] = deep_copy(snapshot) }
+          execution_id
+        end
+
+        def fetch(execution_id)
+          @mutex.synchronize { deep_copy(@snapshots.fetch(execution_id)) }
+        rescue KeyError
+          raise Igniter::ResolutionError, "No execution snapshot found for '#{execution_id}'"
+        end
+
+        def delete(execution_id)
+          @mutex.synchronize { @snapshots.delete(execution_id) }
+        end
+
+        def exist?(execution_id)
+          @mutex.synchronize { @snapshots.key?(execution_id) }
+        end
+
+        private
+
+        def deep_copy(value)
+          Marshal.load(Marshal.dump(value))
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/stores/redis_store.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Runtime
+    module Stores
+      class RedisStore
+        def initialize(redis:, namespace: "igniter:executions")
+          @redis = redis
+          @namespace = namespace
+        end
+
+        def save(snapshot)
+          execution_id = snapshot[:execution_id] || snapshot["execution_id"]
+          @redis.set(redis_key(execution_id), JSON.generate(snapshot))
+          execution_id
+        end
+
+        def fetch(execution_id)
+          payload = @redis.get(redis_key(execution_id))
+          raise Igniter::ResolutionError, "No execution snapshot found for '#{execution_id}'" unless payload
+
+          JSON.parse(payload)
+        end
+
+        def delete(execution_id)
+          @redis.del(redis_key(execution_id))
+        end
+
+        def exist?(execution_id)
+          result = @redis.exists?(redis_key(execution_id))
+          result == true || result.to_i.positive?
+        end
+
+        private
+
+        def redis_key(execution_id)
+          "#{@namespace}:#{execution_id}"
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime.rb

@@ -2,7 +2,19 @@
 
 require_relative "runtime/node_state"
 require_relative "runtime/cache"
+require_relative "runtime/deferred_result"
+require_relative "runtime/collection_result"
 require_relative "runtime/input_validator"
+require_relative "runtime/planner"
+require_relative "runtime/job_worker"
+require_relative "runtime/runners/inline_runner"
+require_relative "runtime/runners/store_runner"
+require_relative "runtime/runners/thread_pool_runner"
+require_relative "runtime/stores/active_record_store"
+require_relative "runtime/stores/file_store"
+require_relative "runtime/stores/memory_store"
+require_relative "runtime/stores/redis_store"
+require_relative "runtime/runner_factory"
 require_relative "runtime/resolver"
 require_relative "runtime/invalidator"
 require_relative "runtime/result"