igniter 0.3.0 → 0.4.0

data/lib/igniter/server/handlers/base.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Server
+    module Handlers
+      class Base
+        def initialize(registry, store)
+          @registry = registry
+          @store    = store
+        end
+
+        def call(params:, body:)
+          handle(params: params, body: body)
+        rescue Igniter::Server::Registry::RegistryError => e
+          json_error(e.message, status: 404)
+        rescue Igniter::Error => e
+          json_error(e.message, status: 422)
+        rescue StandardError => e
+          json_error("Internal server error: #{e.message}", status: 500)
+        end
+
+        private
+
+        def handle(params:, body:)
+          raise NotImplementedError, "#{self.class}#handle must be implemented"
+        end
+
+        def json_ok(data)
+          { status: 200, body: JSON.generate(data), headers: json_ct }
+        end
+
+        def json_error(message, status: 422)
+          { status: status, body: JSON.generate({ error: message }), headers: json_ct }
+        end
+
+        def json_ct
+          { "Content-Type" => "application/json" }
+        end
+
+        # Serialize a contract execution result into the standard API response hash.
+        # Reads the cache directly to avoid calling contract.pending?/failed? which
+        # internally re-invoke resolve_all and would re-raise on failed nodes.
+        def serialize_execution(contract, contract_class) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          execution_id = contract.execution.events.execution_id
+          cache_values = contract.execution.cache.values
+
+          if cache_values.any?(&:pending?)
+            pending_nodes = cache_values.select(&:pending?)
+            waiting_for   = pending_nodes.filter_map { |s| s.value.payload[:event]&.to_s }
+            { execution_id: execution_id, status: "pending", waiting_for: waiting_for }
+          elsif cache_values.any?(&:failed?)
+            error_state = cache_values.find(&:failed?)
+            { execution_id: execution_id, status: "failed",
+              error: serialize_error(error_state&.error) }
+          else
+            outputs = serialize_outputs(contract, contract_class)
+            { execution_id: execution_id, status: "succeeded", outputs: outputs }
+          end
+        end
+
+        def serialize_outputs(contract, contract_class)
+          contract_class.compiled_graph.outputs.each_with_object({}) do |output, memo|
+            memo[output.name] = to_json_value(contract.result.public_send(output.name))
+          rescue StandardError
+            nil
+          end
+        end
+
+        def serialize_error(error)
+          return { message: "Unknown error" } unless error
+
+          {
+            type: error.class.name,
+            message: error.message,
+            node: error.context[:node_name]
+          }
+        end
+
+        # Recursively convert a value into JSON-safe primitives.
+        def to_json_value(value) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          case value
+          when Hash
+            value.each_with_object({}) { |(k, v), h| h[k.to_s] = to_json_value(v) }
+          when Array
+            value.map { |v| to_json_value(v) }
+          when String, Integer, Float, TrueClass, FalseClass, NilClass
+            value
+          when Symbol
+            value.to_s
+          else
+            value.respond_to?(:to_h) ? to_json_value(value.to_h) : value.to_s
+          end
+        end
+
+        def symbolize_inputs(hash)
+          return {} unless hash.is_a?(Hash)
+
+          hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/contracts_handler.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      class ContractsHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          json_ok(@registry.introspect)
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/event_handler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      class EventHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Metrics/MethodLength
+          contract_class = @registry.fetch(params[:name])
+          event       = body["event"]&.to_sym
+          correlation = symbolize_inputs(body["correlation"] || {})
+          payload     = body["payload"] || {}
+
+          raise Igniter::Error, "event name is required" unless event
+
+          contract = contract_class.deliver_event(event,
+                                                  correlation: correlation,
+                                                  payload: payload,
+                                                  store: @store)
+          contract.resolve_all unless contract.success? || contract.failed?
+
+          json_ok(serialize_execution(contract, contract_class))
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/execute_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      class ExecuteHandler < Base
+        private
+
+        def handle(params:, body:)
+          contract_class = @registry.fetch(params[:name])
+          inputs = symbolize_inputs(body["inputs"] || {})
+          contract = run_contract(contract_class, inputs)
+          json_ok(serialize_execution(contract, contract_class))
+        end
+
+        def run_contract(contract_class, inputs) # rubocop:disable Metrics/MethodLength
+          if use_distributed_start?(contract_class)
+            contract_class.start(inputs, store: @store)
+          else
+            contract = contract_class.new(inputs)
+            begin
+              contract.resolve_all
+            rescue Igniter::Error
+              nil # failed state is already written to cache; serialize_execution handles it
+            end
+            contract
+          end
+        end
+
+        # Use .start for contracts that declare correlate_by (distributed workflows).
+        def use_distributed_start?(contract_class)
+          contract_class.respond_to?(:correlation_keys) && !contract_class.correlation_keys.empty?
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/health_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      class HealthHandler < Base
+        def initialize(registry, store, node_url: nil)
+          super(registry, store)
+          @node_url = node_url
+        end
+
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument,Metrics/MethodLength
+          pending_count = begin
+            @store.list_pending.size
+          rescue StandardError
+            0
+          end
+
+          json_ok({
+                    status: "ok",
+                    node: @node_url,
+                    contracts: @registry.names,
+                    store: @store.class.name.split("::").last,
+                    pending: pending_count
+                  })
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/handlers/status_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      class StatusHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          execution_id = params[:id]
+          snapshot     = @store.fetch(execution_id)
+          states       = snapshot[:states] || snapshot["states"] || {}
+
+          pending = states.values.any? { |s| (s[:status] || s["status"]).to_s == "pending" }
+          failed  = states.values.any? { |s| (s[:status] || s["status"]).to_s == "failed" }
+
+          status = if pending then "pending"
+                   elsif failed then "failed"
+                   else "succeeded"
+                   end
+
+          json_ok({ execution_id: execution_id, status: status })
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/http_server.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Igniter
+  module Server
+    # Pure-Ruby HTTP/1.1 server built on TCPServer (stdlib, zero external deps).
+    # Spawns one thread per connection. Intended for development and orchestration use.
+    # For production, use RackApp with Puma via `Igniter::Server.rack_app`.
+    class HttpServer
+      CRLF = "\r\n"
+      STATUS_MESSAGES = {
+        200 => "OK",
+        400 => "Bad Request",
+        404 => "Not Found",
+        422 => "Unprocessable Entity",
+        500 => "Internal Server Error"
+      }.freeze
+
+      def initialize(config)
+        @config = config
+        @router = Router.new(config)
+      end
+
+      def start # rubocop:disable Metrics/MethodLength
+        @tcp_server = TCPServer.new(@config.host, @config.port)
+        @running    = true
+
+        trap("INT")  { stop }
+        trap("TERM") { stop }
+
+        log("igniter-server listening on http://#{@config.host}:#{@config.port}")
+
+        loop do
+          break unless @running
+
+          client = accept_connection
+          Thread.new(client) { |conn| handle_connection(conn) } if client
+        end
+      rescue IOError
+        # Server socket closed via stop
+      end
+
+      def stop
+        @running = false
+        @tcp_server&.close
+      end
+
+      private
+
+      def accept_connection
+        @tcp_server.accept_nonblock
+      rescue IO::WaitReadable
+        IO.select([@tcp_server], nil, nil, 0.5)
+        nil
+      rescue IOError
+        nil
+      end
+
+      def handle_connection(socket) # rubocop:disable Metrics/MethodLength
+        request_line = socket.gets&.chomp
+        return unless request_line&.include?(" ")
+
+        http_method, path, = request_line.split(" ", 3)
+        headers = read_headers(socket)
+        body    = read_body(socket, headers["content-length"].to_i)
+
+        result = @router.call(http_method, path, body)
+        write_response(socket, result)
+      rescue StandardError => e
+        log("Connection error: #{e.message}")
+      ensure
+        socket.close rescue nil # rubocop:disable Style/RescueModifier
+      end
+
+      def read_headers(socket)
+        headers = {}
+        while (line = socket.gets&.chomp) && !line.empty?
+          name, value = line.split(": ", 2)
+          headers[name.downcase] = value if name
+        end
+        headers
+      end
+
+      def read_body(socket, length)
+        length.positive? ? socket.read(length).to_s : ""
+      end
+
+      def write_response(socket, result)
+        body   = result[:body].to_s
+        code   = result[:status].to_i
+        phrase = STATUS_MESSAGES.fetch(code, "Unknown")
+
+        response  = "HTTP/1.1 #{code} #{phrase}#{CRLF}"
+        response += "Content-Type: application/json#{CRLF}"
+        response += "Content-Length: #{body.bytesize}#{CRLF}"
+        response += "Connection: close#{CRLF}"
+        response += CRLF
+        response += body
+
+        socket.write(response)
+      end
+
+      def log(message)
+        @config.logger&.puts(message) || $stdout.puts(message)
+      end
+    end
+  end
+end

data/lib/igniter/server/rack_app.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    # Rack-compatible application adapter.
+    # Allows igniter-server to run under any Rack-compatible server (Puma, Unicorn, etc.).
+    #
+    # Usage in config.ru:
+    #   require "igniter/server"
+    #   Igniter::Server.configure { |c| c.register "MyContract", MyContract }
+    #   run Igniter::Server.rack_app
+    class RackApp
+      def initialize(config)
+        @router = Router.new(config)
+      end
+
+      def call(env) # rubocop:disable Metrics/MethodLength
+        method   = env["REQUEST_METHOD"]
+        path     = env["PATH_INFO"]
+        body_str = env["rack.input"].read
+
+        result = @router.call(method, path, body_str)
+
+        [
+          result[:status],
+          result[:headers].merge("Content-Length" => result[:body].bytesize.to_s),
+          [result[:body]]
+        ]
+      rescue StandardError => e
+        error_body = JSON.generate({ error: "Internal server error: #{e.message}" })
+        [500, { "Content-Type" => "application/json" }, [error_body]]
+      end
+    end
+  end
+end

data/lib/igniter/server/registry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    class Registry
+      class RegistryError < Igniter::Server::Error; end
+
+      def initialize
+        @contracts = {}
+        @mutex = Mutex.new
+      end
+
+      def register(name, contract_class)
+        unless contract_class.is_a?(Class) && contract_class <= Igniter::Contract
+          raise RegistryError, "'#{name}' must be an Igniter::Contract subclass"
+        end
+
+        @mutex.synchronize { @contracts[name.to_s] = contract_class }
+        self
+      end
+
+      def fetch(name)
+        @mutex.synchronize do
+          @contracts.fetch(name.to_s) do
+            raise RegistryError, "Contract '#{name}' is not registered. " \
+                                 "Available: #{@contracts.keys.inspect}"
+          end
+        end
+      end
+
+      def all
+        @mutex.synchronize { @contracts.dup }
+      end
+
+      def names
+        @mutex.synchronize { @contracts.keys }
+      end
+
+      def registered?(name)
+        @mutex.synchronize { @contracts.key?(name.to_s) }
+      end
+
+      # Returns a description of each registered contract for introspection.
+      def introspect
+        all.map do |name, klass|
+          graph = klass.compiled_graph
+          {
+            name: name,
+            inputs: graph.nodes.select { |n| n.kind == :input }.map(&:name),
+            outputs: graph.outputs.map(&:name)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/igniter/server/router.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Server
+    # Transport-agnostic HTTP router.
+    # Receives (method, path, body_string) and returns { status:, body:, headers: }.
+    # Used by both HttpServer (TCPServer) and RackApp.
+    class Router
+      ROUTES = [
+        { method: "GET",  pattern: %r{\A/v1/health\z}, handler: :health },
+        { method: "GET",  pattern: %r{\A/v1/contracts\z},                             handler: :contracts },
+        { method: "POST", pattern: %r{\A/v1/contracts/(?<name>[^/]+)/execute\z},      handler: :execute },
+        { method: "POST", pattern: %r{\A/v1/contracts/(?<name>[^/]+)/events\z},       handler: :event },
+        { method: "GET",  pattern: %r{\A/v1/executions/(?<id>[^/]+)\z},               handler: :status }
+      ].freeze
+
+      def initialize(config)
+        @config = config
+      end
+
+      # Main dispatch entry point — called by both WEBrick and Rack adapters.
+      def call(http_method, path, body_str) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        method_uc = http_method.to_s.upcase
+        ROUTES.each do |route|
+          next unless route[:method] == method_uc
+
+          match = route[:pattern].match(path)
+          next unless match
+
+          params = match.named_captures.transform_keys(&:to_sym)
+          body   = parse_body(body_str)
+
+          handler = build_handler(route[:handler])
+          return handler.call(params: params, body: body)
+        end
+
+        not_found_response(path)
+      rescue JSON::ParserError => e
+        { status: 400, body: JSON.generate({ error: "Invalid JSON: #{e.message}" }), headers: json_ct }
+      end
+
+      private
+
+      def build_handler(key)
+        registry = @config.registry
+        store    = @config.store
+        node_url = "http://#{@config.host}:#{@config.port}"
+
+        case key
+        when :health     then Handlers::HealthHandler.new(registry, store, node_url: node_url)
+        when :contracts  then Handlers::ContractsHandler.new(registry, store)
+        when :execute    then Handlers::ExecuteHandler.new(registry, store)
+        when :event      then Handlers::EventHandler.new(registry, store)
+        when :status     then Handlers::StatusHandler.new(registry, store)
+        end
+      end
+
+      def parse_body(str)
+        return {} if str.nil? || str.strip.empty?
+
+        JSON.parse(str)
+      end
+
+      def not_found_response(path)
+        { status: 404, body: JSON.generate({ error: "Not found: #{path}" }), headers: json_ct }
+      end
+
+      def json_ct
+        { "Content-Type" => "application/json" }
+      end
+    end
+  end
+end

data/lib/igniter/server.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "igniter"
+require "json"
+
+# Define the top-level Server module and Error class first,
+# so subfiles can inherit from Igniter::Server::Error.
+module Igniter
+  module Server
+    class Error < Igniter::Error; end
+  end
+end
+
+require_relative "server/registry"
+require_relative "server/config"
+require_relative "server/router"
+require_relative "server/http_server"
+require_relative "server/rack_app"
+require_relative "server/client"
+require_relative "server/handlers/base"
+require_relative "server/handlers/health_handler"
+require_relative "server/handlers/contracts_handler"
+require_relative "server/handlers/execute_handler"
+require_relative "server/handlers/event_handler"
+require_relative "server/handlers/status_handler"
+
+module Igniter
+  module Server
+    class << self
+      def config
+        @config ||= Config.new
+      end
+
+      def configure
+        yield config
+        self
+      end
+
+      # Start the built-in HTTP server (blocking).
+      def start(**options)
+        apply_options!(options)
+        HttpServer.new(config).start
+      end
+
+      # Return a Rack-compatible application for use with Puma/Unicorn/etc.
+      def rack_app
+        RackApp.new(config)
+      end
+
+      # Reset configuration (useful in tests).
+      def reset!
+        @config = nil
+      end
+
+      private
+
+      def apply_options!(options) # rubocop:disable Metrics/AbcSize
+        config.port  = options[:port]  if options[:port]
+        config.host  = options[:host]  if options[:host]
+        config.store = options[:store] if options[:store]
+        return unless options[:contracts].is_a?(Hash)
+
+        options[:contracts].each { |name, klass| config.register(name.to_s, klass) }
+      end
+    end
+  end
+end

data/lib/igniter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Igniter
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/igniter.rb

@@ -39,5 +39,9 @@ module Igniter
     def compile_schema(schema, name: nil)
       DSL::SchemaBuilder.compile(schema, name: name)
     end
+
+    def configure
+      yield self
+    end
   end
 end