igniter 0.4.5 → 0.5.1

data/packages/igniter-server/lib/igniter/server/http_server.rb

@@ -0,0 +1,222 @@
+# 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 # rubocop:disable Metrics/ClassLength
+      CRLF = "\r\n"
+      STATUS_MESSAGES = {
+        200 => "OK",
+        303 => "See Other",
+        400 => "Bad Request",
+        404 => "Not Found",
+        422 => "Unprocessable Entity",
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        503 => "Service Unavailable"
+      }.freeze
+
+      def initialize(config)
+        @config       = config
+        @router       = Router.new(config)
+        @logger       = ServerLogger.new(format: config.log_format)
+        @config.logger ||= @logger
+        @in_flight    = 0
+        @in_flight_mu = Mutex.new
+        @connections  = {}
+        @connections_mu = Mutex.new
+      end
+
+      def start # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        @tcp_server = TCPServer.new(@config.host, @config.port)
+        @running    = true
+        @shutdown_mode = nil
+
+        trap("INT")  { request_shutdown(:immediate) }
+        trap("TERM") { request_shutdown(:graceful) }
+
+        @logger.info("igniter-stack started",
+                     host: @config.host, port: @config.port, pid: Process.pid)
+        run_after_start_hooks!
+
+        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
+      ensure
+        if @shutdown_mode == :graceful
+          @logger.info("SIGTERM received — draining",
+                       drain_timeout: @config.drain_timeout, pid: Process.pid)
+          drain_in_flight
+        elsif @shutdown_mode == :immediate
+          close_active_connections
+        end
+        @logger.info("igniter-stack stopped", pid: Process.pid)
+      end
+
+      def stop
+        request_shutdown(:immediate)
+      end
+
+      def graceful_stop
+        request_shutdown(:graceful)
+      end
+
+      private
+
+      def request_shutdown(mode)
+        @shutdown_mode ||= mode
+        @running = false
+        @tcp_server&.close
+      rescue IOError, Errno::EBADF
+        nil
+      end
+
+      def accept_connection
+        @tcp_server.accept_nonblock
+      rescue IO::WaitReadable
+        return nil unless @running
+
+        begin
+          IO.select([@tcp_server], nil, nil, 0.5)
+        rescue IOError, Errno::EBADF
+          nil
+        end
+        nil
+      rescue IOError, Errno::EBADF
+        nil
+      end
+
+      def handle_connection(socket) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        register_connection(socket)
+        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)
+
+        with_in_flight do
+          result = @router.call(http_method, path, body, headers: headers)
+          write_response(socket, result)
+          @logger.info("#{http_method} #{path}", status: result[:status])
+        end
+      rescue StandardError => e
+        @logger.error("Connection error", error: e.message)
+      ensure
+        unregister_connection(socket)
+        socket.close rescue nil # rubocop:disable Style/RescueModifier
+      end
+
+      def with_in_flight
+        @in_flight_mu.synchronize { @in_flight += 1 }
+        yield
+      ensure
+        @in_flight_mu.synchronize { @in_flight -= 1 }
+      end
+
+      def drain_in_flight
+        timeout  = @config.drain_timeout.to_i
+        deadline = Time.now + timeout
+
+        loop do
+          remaining = @in_flight_mu.synchronize { @in_flight }
+          break if remaining.zero?
+          break if Time.now > deadline
+
+          @logger.info("Draining in-flight connections", remaining: remaining)
+          sleep 0.1
+        end
+      end
+
+      def register_connection(socket)
+        @connections_mu.synchronize { @connections[socket.object_id] = socket }
+      end
+
+      def unregister_connection(socket)
+        @connections_mu.synchronize { @connections.delete(socket.object_id) }
+      end
+
+      def close_active_connections
+        sockets = @connections_mu.synchronize { @connections.values.dup }
+        sockets.each do |socket|
+          socket.close
+        rescue IOError, Errno::EBADF
+          nil
+        end
+      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) # rubocop:disable Metrics/MethodLength
+        return write_stream_response(socket, result) if result[:stream]
+
+        body   = result[:body].to_s
+        code   = result[:status].to_i
+        phrase = STATUS_MESSAGES.fetch(code, "Unknown")
+        headers = (result[:headers] || {}).dup
+        ct     = headers.delete("Content-Type") || "application/json"
+
+        response  = "HTTP/1.1 #{code} #{phrase}#{CRLF}"
+        response += "Content-Type: #{ct}#{CRLF}"
+        headers.each do |key, value|
+          response += "#{key}: #{value}#{CRLF}"
+        end
+        response += "Content-Length: #{body.bytesize}#{CRLF}"
+        response += "Connection: close#{CRLF}"
+        response += CRLF
+        response += body
+
+        socket.write(response)
+      end
+
+      def write_stream_response(socket, result)
+        code = result[:status].to_i
+        phrase = STATUS_MESSAGES.fetch(code, "Unknown")
+        headers = result[:headers] || {}
+
+        response = +"HTTP/1.1 #{code} #{phrase}#{CRLF}"
+        headers.each do |key, value|
+          response << "#{key}: #{value}#{CRLF}"
+        end
+        response << "Connection: close#{CRLF}"
+        response << CRLF
+
+        socket.write(response)
+        Array(result[:body]).each { |chunk| socket.write(chunk.to_s) } unless result[:body].respond_to?(:each)
+        return unless result[:body].respond_to?(:each)
+
+        result[:body].each do |chunk|
+          socket.write(chunk.to_s)
+        end
+      end
+
+      def run_after_start_hooks!
+        Array(@config.after_start_hooks).each do |hook|
+          hook.call(config: @config, server: self)
+        end
+      rescue StandardError => e
+        @logger.error("after_start hook failed", error: e.message)
+      end
+    end
+  end
+end

data/{lib → packages/igniter-server/lib}/igniter/server/rack_app.rb

@@ -3,7 +3,7 @@
 module Igniter
   module Server
     # Rack-compatible application adapter.
-    # Allows igniter-server to run under any Rack-compatible server (Puma, Unicorn, etc.).
+    # Allows igniter-stack to run under any Rack-compatible server (Puma, Unicorn, etc.).
     #
     # Usage in config.ru:
     #   require "igniter/server"
@@ -11,6 +11,7 @@ module Igniter
     #   run Igniter::Server.rack_app
     class RackApp
       def initialize(config)
+        config.logger ||= ServerLogger.new(format: config.log_format)
         @router = Router.new(config)
       end
 
@@ -19,7 +20,15 @@ module Igniter
         path     = env["PATH_INFO"]
         body_str = env["rack.input"].read
 
-        result = @router.call(method, path, body_str)
+        result = @router.call(method, path, body_str, headers: request_headers(env), env: env)
+
+        if result[:stream]
+          return [
+            result[:status],
+            result[:headers],
+            result[:body]
+          ]
+        end
 
         [
           result[:status],
@@ -30,6 +39,22 @@ module Igniter
         error_body = JSON.generate({ error: "Internal server error: #{e.message}" })
         [500, { "Content-Type" => "application/json" }, [error_body]]
       end
+
+      private
+
+      def request_headers(env)
+        env.each_with_object({}) do |(key, value), memo|
+          case key
+          when /\AHTTP_(.+)\z/
+            name = Regexp.last_match(1).split("_").map(&:capitalize).join("-")
+            memo[name] = value
+          when "CONTENT_TYPE"
+            memo["Content-Type"] = value
+          when "CONTENT_LENGTH"
+            memo["Content-Length"] = value
+          end
+        end
+      end
     end
   end
 end

data/packages/igniter-server/lib/igniter/server/remote_adapter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    # HTTP/mesh transport adapter for Runtime remote nodes.
+    class RemoteAdapter < Igniter::Runtime::RemoteAdapter
+      def call(node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
+        url = resolve_url(node)
+        Client.new(url, timeout: node.timeout).execute(node.contract_name, inputs: inputs)
+      rescue Client::ConnectionError => e
+        raise ResolutionError, "Cannot reach #{url}: #{e.message}"
+      end
+
+      private
+
+      def resolve_url(node)
+        case node.routing_mode
+        when :static
+          node.node_url
+        else
+          raise ResolutionError,
+                "remote :#{node.name} uses #{node.routing_mode} routing — add `require 'igniter/cluster'`"
+        end
+      end
+    end
+  end
+end

data/packages/igniter-server/lib/igniter/server/router.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "json"
+require "stringio"
+require "uri"
+
+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/live\z},                             handler: :liveness },
+        { method: "GET",    pattern: %r{\A/v1/ready\z},                            handler: :readiness },
+        { method: "GET",    pattern: %r{\A/v1/metrics\z},                          handler: :metrics },
+        { method: "GET",    pattern: %r{\A/v1/health\z},                           handler: :health },
+        { method: "GET",    pattern: %r{\A/v1/manifest\z},                         handler: :manifest },
+        { method: "GET",    pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_list },
+        { method: "GET",    pattern: %r{\A/v1/mesh/sd\z}, handler: :mesh_sd },
+        { method: "POST",   pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_register },
+        { method: "DELETE", pattern: %r{\A/v1/mesh/peers/(?<name>.+)\z},           handler: :mesh_peers_delete },
+        { 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: "POST",   pattern: %r{\A/v1/agents/(?<via>[^/]+)/messages/(?<message>[^/]+)/call\z}, handler: :agent_call },
+        { method: "POST",   pattern: %r{\A/v1/agents/(?<via>[^/]+)/messages/(?<message>[^/]+)/cast\z}, handler: :agent_cast },
+        { method: "POST",   pattern: %r{\A/v1/agent-sessions/(?<token>[^/]+)/continue\z}, handler: :agent_session_continue },
+        { method: "POST",   pattern: %r{\A/v1/agent-sessions/(?<token>[^/]+)/resume\z}, handler: :agent_session_resume },
+        { 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 HttpServer and RackApp.
+      # Records HTTP metrics when a collector is configured.
+      def call(http_method, path, body_str, headers: {}, env: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        started_at = Time.now.utc
+        method_uc  = http_method.to_s.upcase
+        normalized_path = normalize_path(path)
+        body = parse_body(body_str, headers)
+
+        custom_result = dispatch_custom_route(
+          method_uc,
+          normalized_path,
+          body,
+          headers: headers,
+          env: env,
+          raw_body: body_str,
+          raw_path: path
+        )
+        if custom_result
+          record_http_metric(method_uc, normalized_path, custom_result[:status], started_at)
+          return custom_result
+        end
+
+        ROUTES.each do |route|
+          next unless route[:method] == method_uc
+
+          match = route[:pattern].match(normalized_path)
+          next unless match
+
+          params  = match.named_captures.transform_keys(&:to_sym)
+          handler = build_handler(route[:handler])
+          result  = handler.call(params: params, body: body)
+
+          record_http_metric(method_uc, normalized_path, result[:status], started_at)
+          return result
+        end
+
+        result = not_found_response(normalized_path)
+        record_http_metric(method_uc, normalized_path, 404, started_at)
+        result
+      rescue JSON::ParserError => e
+        { status: 400, body: JSON.generate({ error: "Invalid JSON: #{e.message}" }), headers: json_ct }
+      end
+
+      private
+
+      def build_handler(key) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+        registry  = @config.registry
+        store     = @config.store
+        node_url  = "http://#{@config.host}:#{@config.port}"
+        collector = @config.metrics_collector
+
+        case key
+        when :liveness           then Handlers::LivenessHandler.new(registry, store)
+        when :readiness          then Handlers::ReadinessHandler.new(registry, store)
+        when :metrics            then Handlers::MetricsHandler.new(registry, store, collector: collector)
+        when :health             then Handlers::HealthHandler.new(registry, store, node_url: node_url)
+        when :manifest           then Handlers::ManifestHandler.new(registry, store, config: @config)
+        when :mesh_peers_list    then Handlers::MeshPeersListHandler.new(registry, store)
+        when :mesh_sd            then Handlers::MeshSdHandler.new(registry, store)
+        when :mesh_peers_register then Handlers::MeshPeersRegisterHandler.new(registry, store)
+        when :mesh_peers_delete  then Handlers::MeshPeersDeleteHandler.new(registry, store)
+        when :contracts          then Handlers::ContractsHandler.new(registry, store)
+        when :execute            then Handlers::ExecuteHandler.new(registry, store, collector: collector)
+        when :event              then Handlers::EventHandler.new(registry, store, collector: collector)
+        when :agent_call         then Handlers::AgentMessageHandler.new(registry, store, session_store: @config.agent_session_store, mode: :call)
+        when :agent_cast         then Handlers::AgentMessageHandler.new(registry, store, session_store: @config.agent_session_store, mode: :cast)
+        when :agent_session_continue then Handlers::AgentSessionHandler.new(registry, store, session_store: @config.agent_session_store, mode: :continue)
+        when :agent_session_resume then Handlers::AgentSessionHandler.new(registry, store, session_store: @config.agent_session_store, mode: :resume)
+        when :status             then Handlers::StatusHandler.new(registry, store)
+        end
+      end
+
+      def dispatch_custom_route(method, path, body, headers:, env:, raw_body:, raw_path:)
+        request_env = normalized_request_env(method, path, raw_path, headers, raw_body, env)
+
+        Array(@config.custom_routes).each do |route|
+          next unless route[:method] == method
+
+          params = match_custom_path(route[:path], path)
+          next unless params
+
+          request = {
+            method: method,
+            path: path,
+            params: params,
+            body: body,
+            headers: headers,
+            env: request_env,
+            raw_body: raw_body,
+            config: @config,
+            route: route
+          }
+
+          Array(@config.before_request_hooks).each { |hook| hook.call(request: request) }
+
+          result = build_custom_route_pipeline(request).call
+          response = coerce_custom_result(result)
+
+          Array(@config.after_request_hooks).each do |hook|
+            hook.call(request: request, response: response)
+          end
+
+          return response
+        end
+
+        nil
+      end
+
+      def normalized_request_env(method, path, raw_path, headers, raw_body, env)
+        query_string = raw_path.to_s.split("?", 2)[1].to_s
+        normalized_headers = headers.to_h.each_with_object({}) do |(key, value), memo|
+          canonical_key = key.to_s
+          next if canonical_key.empty?
+
+          env_key =
+            case canonical_key.downcase
+            when "content-type"
+              "CONTENT_TYPE"
+            when "content-length"
+              "CONTENT_LENGTH"
+            else
+              "HTTP_#{canonical_key.upcase.tr("-", "_")}"
+            end
+
+          memo[env_key] = value.to_s
+        end
+
+        {
+          "REQUEST_METHOD" => method.to_s.upcase,
+          "PATH_INFO" => normalize_path(path),
+          "QUERY_STRING" => query_string,
+          "rack.input" => StringIO.new(raw_body.to_s)
+        }.merge(normalized_headers).merge(env.to_h)
+      end
+
+      def build_custom_route_pipeline(request)
+        route = request.fetch(:route)
+        handler_call = lambda do
+          route.fetch(:handler).call(
+            params: request[:params],
+            body: request[:body],
+            headers: request[:headers],
+            env: request[:env],
+            raw_body: request[:raw_body],
+            config: request[:config]
+          )
+        end
+
+        Array(@config.around_request_hooks).reverse_each.reduce(handler_call) do |inner, hook|
+          lambda do
+            hook.call(request: request, &inner)
+          end
+        end
+      end
+
+      def match_custom_path(pattern, path)
+        case pattern
+        when String
+          pattern == path ? {} : nil
+        when Regexp
+          match = pattern.match(path)
+          match ? match.named_captures.transform_keys(&:to_sym) : nil
+        else
+          raise ArgumentError, "Custom route path must be a String or Regexp"
+        end
+      end
+
+      def coerce_custom_result(result)
+        if custom_response_hash?(result)
+          stream = result[:stream] || result["stream"]
+          {
+            status: integer_or_default(result[:status] || result["status"], 200),
+            body: stream ? (result[:body] || result["body"]) : serialize_custom_body(result[:body] || result["body"]),
+            headers: (result[:headers] || result["headers"] || json_ct).transform_keys(&:to_s),
+            stream: !!stream
+          }
+        else
+          { status: 200, body: serialize_custom_body(result), headers: json_ct }
+        end
+      end
+
+      def custom_response_hash?(result)
+        result.is_a?(Hash) && (result.key?(:status) || result.key?("status") ||
+          result.key?(:body) || result.key?("body") || result.key?(:headers) || result.key?("headers"))
+      end
+
+      def serialize_custom_body(body)
+        case body
+        when String
+          body
+        when nil
+          ""
+        else
+          JSON.generate(body)
+        end
+      end
+
+      def integer_or_default(value, default)
+        value.nil? ? default : value.to_i
+      end
+
+      def record_http_metric(method, path, status, started_at)
+        return unless @config.metrics_collector
+
+        duration = Time.now.utc - started_at
+        @config.metrics_collector.record_http(
+          method: method, path: path, status: status, duration: duration
+        )
+      end
+
+      def parse_body(str, headers = {})
+        return {} if str.nil? || str.strip.empty?
+
+        case request_content_type(headers)
+        when "application/x-www-form-urlencoded"
+          parse_form_body(str)
+        else
+          JSON.parse(str)
+        end
+      end
+
+      def parse_form_body(str)
+        URI.decode_www_form(str).each_with_object({}) do |(key, value), memo|
+          if memo.key?(key)
+            memo[key] = Array(memo[key]) << value
+          else
+            memo[key] = value
+          end
+        end
+      end
+
+      def request_content_type(headers)
+        headers.to_h.each do |key, value|
+          next unless key.to_s.casecmp("Content-Type").zero?
+
+          return value.to_s.split(";", 2).first.strip.downcase
+        end
+
+        nil
+      end
+
+      def normalize_path(path)
+        path.to_s.split("?", 2).first
+      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/packages/igniter-server/lib/igniter/server/server_logger.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Server
+    # Minimal structured logger for igniter-stack.
+    #
+    # format: :json  → each line is a JSON object (Loki/ELK/CloudWatch compatible)
+    # format: :text  → human-readable single-line string
+    #
+    # Thread-safe via an internal Mutex.
+    class ServerLogger
+      def initialize(format: :text, out: $stdout)
+        @format = format
+        @out    = out
+        @mutex  = Mutex.new
+      end
+
+      def info(message, **context)
+        log("INFO", message, context)
+      end
+
+      def warn(message, **context)
+        log("WARN", message, context)
+      end
+
+      def error(message, **context)
+        log("ERROR", message, context)
+      end
+
+      private
+
+      def log(level, message, context)
+        line = @format == :json ? json_line(level, message, context) : text_line(level, message, context)
+        @mutex.synchronize { @out.puts(line) }
+      rescue ThreadError
+        @out.puts(line)
+      end
+
+      def json_line(level, message, context)
+        JSON.generate(
+          { time: Time.now.utc.iso8601(3), level: level, msg: message }.merge(context)
+        )
+      end
+
+      def text_line(level, message, context)
+        ts    = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+        extra = context.empty? ? "" : " #{context.map { |k, v| "#{k}=#{v}" }.join(" ")}"
+        "[#{ts}] #{level} #{message}#{extra}"
+      end
+    end
+  end
+end