igniter 0.4.5 → 0.5.1

data/lib/igniter/server/config.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    class Config
-      attr_accessor :host, :port, :store, :logger
-      attr_reader   :registry
-
-      def initialize
-        @host     = "0.0.0.0"
-        @port     = 4567
-        @store    = Igniter::Runtime::Stores::MemoryStore.new
-        @registry = Registry.new
-        @logger   = nil
-      end
-
-      def register(name, contract_class)
-        @registry.register(name, contract_class)
-        self
-      end
-
-      def contracts=(hash)
-        hash.each { |name, klass| register(name.to_s, klass) }
-      end
-    end
-  end
-end

data/lib/igniter/server/http_server.rb

@@ -1,109 +0,0 @@
-# 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/router.rb

@@ -1,75 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-# 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