igniter 0.5.0 → 0.5.2

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      # Returns a JSON manifest describing this peer: its name, advertised
-      # capabilities, registered contracts, and its base URL.
-      # Used by Igniter::Mesh::Router health-probing and peer discovery.
-      class ManifestHandler < Base
-        def initialize(registry, store, config: nil)
-          super(registry, store)
-          @config = config
-        end
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          json_ok({
-                    peer_name: @config&.peer_name,
-                    capabilities: (@config&.peer_capabilities || []).map(&:to_s),
-                    contracts: @registry.names,
-                    url: node_url
-                  })
-        end
-
-        def node_url
-          return nil unless @config
-
-          "http://#{@config.host}:#{@config.port}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/metrics"
-
-module Igniter
-  module Server
-    module Handlers
-      # GET /v1/metrics — Prometheus text format metrics endpoint.
-      #
-      # Requires a Collector to be configured on the server:
-      #   Igniter::Server.configure { |c| c.metrics_collector = Igniter::Metrics::Collector.new }
-      #
-      # When no collector is configured, returns a 501 Not Implemented response.
-      class MetricsHandler < Base
-        def initialize(registry, store, collector:)
-          super(registry, store)
-          @collector = collector
-        end
-
-        # Override Base#call to return Prometheus text/plain instead of JSON.
-        def call(params:, body:)
-          handle(params: params, body: body)
-        rescue StandardError => e
-          { status: 500,
-            body: "# ERROR: #{e.message}\n",
-            headers: { "Content-Type" => Igniter::Metrics::PrometheusExporter::CONTENT_TYPE } }
-        end
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          unless @collector
-            return { status: 501,
-                     body: JSON.generate({ error: "metrics_collector not configured" }),
-                     headers: { "Content-Type" => "application/json" } }
-          end
-
-          exporter = Igniter::Metrics::PrometheusExporter.new(
-            @collector,
-            store: @store,
-            registry: @registry
-          )
-
-          { status: 200,
-            body: exporter.export,
-            headers: { "Content-Type" => exporter.content_type } }
-        end
-      end
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module Igniter
-  module Server
-    module Handlers
-      # Shared helper — merges static (add_peer) and dynamic (PeerRegistry) peer pools.
-      # Static entries take precedence when the same name appears in both pools.
-      module MeshPeersMerger
-        private
-
-        def merged_peers
-          return [] unless defined?(Igniter::Mesh)
-
-          static  = Igniter::Mesh.config.peers
-          dynamic = Igniter::Mesh.config.peer_registry.all
-          seen    = static.each_with_object({}) { |p, h| h[p.name] = true }
-          static + dynamic.reject { |p| seen[p.name] }
-        end
-      end
-
-      # GET /v1/mesh/peers
-      # Returns the merged list of static + dynamically discovered peers.
-      class MeshPeersListHandler < Base
-        include MeshPeersMerger
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          json_ok(merged_peers.map do |p|
-            { "name" => p.name, "url" => p.url, "capabilities" => p.capabilities.map(&:to_s) }
-          end)
-        end
-      end
-
-      # GET /v1/mesh/sd
-      # Returns the peer list in Prometheus HTTP SD format so that Prometheus can
-      # dynamically discover all igniter-server scrape targets without a static target list.
-      #
-      # Response shape (one object per peer):
-      #   [{ "targets" => ["host:port"], "labels" => { "__meta_igniter_peer_name" => ..., ... } }]
-      #
-      # Usage in prometheus.yml:
-      #   scrape_configs:
-      #     - job_name: igniter
-      #       http_sd_configs:
-      #         - url: http://any-seed:4567/v1/mesh/sd
-      #           refresh_interval: 30s
-      #       metrics_path: /v1/metrics
-      class MeshSdHandler < Base
-        include MeshPeersMerger
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          json_ok(merged_peers.map { |p| sd_entry(p) })
-        end
-
-        def sd_entry(peer)
-          {
-            "targets" => [host_port(peer.url)],
-            "labels" => {
-              "__meta_igniter_peer_name" => peer.name,
-              "__meta_igniter_capabilities" => peer.capabilities.map(&:to_s).join(",")
-            }
-          }
-        end
-
-        def host_port(url)
-          uri = URI.parse(url)
-          "#{uri.host}:#{uri.port}"
-        rescue URI::InvalidURIError
-          url
-        end
-      end
-
-      # POST /v1/mesh/peers
-      # Body: { "name": "peer-name", "url": "http://host:port", "capabilities": ["a", "b"] }
-      class MeshPeersRegisterHandler < Base
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument, Metrics/AbcSize
-          return json_error("Igniter::Mesh is not loaded", status: 422) unless defined?(Igniter::Mesh)
-
-          name = body["name"].to_s.strip
-          url  = body["url"].to_s.strip
-          return json_error("name is required", status: 400) if name.empty?
-          return json_error("url is required",  status: 400) if url.empty?
-
-          caps = Array(body["capabilities"]).map(&:to_sym)
-          peer = Igniter::Mesh::Peer.new(name: name, url: url, capabilities: caps)
-          Igniter::Mesh.config.peer_registry.register(peer)
-
-          json_ok({ "registered" => true, "name" => name })
-        end
-      end
-
-      # DELETE /v1/mesh/peers/:name
-      # Idempotent — no error if the peer was not registered.
-      class MeshPeersDeleteHandler < Base
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          return json_error("Igniter::Mesh is not loaded", status: 422) unless defined?(Igniter::Mesh)
-
-          name = params[:name].to_s
-          Igniter::Mesh.config.peer_registry.unregister(name)
-
-          json_ok({ "unregistered" => true, "name" => name })
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      # GET /v1/ready — Kubernetes readiness probe.
-      #
-      # Returns 200 when the server is ready to accept traffic:
-      #   - Store is reachable (list_pending does not raise)
-      #   - At least one contract is registered
-      #
-      # Returns 503 when the server should be removed from the load balancer
-      # rotation but NOT restarted. A failing readiness probe causes K8s to
-      # stop routing traffic to the pod without killing it.
-      class ReadinessHandler < Base
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument,Metrics/MethodLength
-          checks = {}
-
-          # Store connectivity check
-          checks[:store] = check_store
-
-          # Contract registration check
-          checks[:contracts] = @registry.names.any? ? "ok" : "no_contracts_registered"
-
-          if checks.values.all? { |v| v == "ok" }
-            json_ok({ status: "ready", checks: checks })
-          else
-            service_unavailable({ status: "not_ready", checks: checks })
-          end
-        end
-
-        def check_store
-          @store.list_pending(graph: nil)
-          "ok"
-        rescue StandardError => e
-          "error: #{e.message}"
-        end
-
-        def service_unavailable(data)
-          { status: 503, body: JSON.generate(data), headers: { "Content-Type" => "application/json" } }
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,146 +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 # rubocop:disable Metrics/ClassLength
-      CRLF = "\r\n"
-      STATUS_MESSAGES = {
-        200 => "OK",
-        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)
-        @in_flight    = 0
-        @in_flight_mu = Mutex.new
-      end
-
-      def start # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        @tcp_server = TCPServer.new(@config.host, @config.port)
-        @running    = true
-
-        trap("INT")  { stop }
-        trap("TERM") { graceful_stop }
-
-        @logger.info("igniter-server started",
-                     host: @config.host, port: @config.port, pid: Process.pid)
-
-        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
-        drain_in_flight
-        @logger.info("igniter-server stopped", pid: Process.pid)
-      end
-
-      def stop
-        @running = false
-        @tcp_server&.close
-      end
-
-      def graceful_stop
-        @logger.info("SIGTERM received — draining",
-                     drain_timeout: @config.drain_timeout, pid: Process.pid)
-        @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,Metrics/AbcSize
-        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)
-          write_response(socket, result)
-          @logger.info("#{http_method} #{path}", status: result[:status])
-        end
-      rescue StandardError => e
-        @logger.error("Connection error", error: e.message)
-      ensure
-        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 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
-        body   = result[:body].to_s
-        code   = result[:status].to_i
-        phrase = STATUS_MESSAGES.fetch(code, "Unknown")
-        ct     = result.dig(:headers, "Content-Type") || "application/json"
-
-        response  = "HTTP/1.1 #{code} #{phrase}#{CRLF}"
-        response += "Content-Type: #{ct}#{CRLF}"
-        response += "Content-Length: #{body.bytesize}#{CRLF}"
-        response += "Connection: close#{CRLF}"
-        response += CRLF
-        response += body
-
-        socket.write(response)
-      end
-    end
-  end
-end

data/lib/igniter/server/rack_app.rb

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

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

@@ -1,108 +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/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: "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) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        started_at = Time.now.utc
-        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])
-          result  = handler.call(params: params, body: body)
-
-          record_http_metric(method_uc, path, result[:status], started_at)
-          return result
-        end
-
-        result = not_found_response(path)
-        record_http_metric(method_uc, 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 :status             then Handlers::StatusHandler.new(registry, store)
-        end
-      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)
-        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/server_logger.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Igniter
-  module Server
-    # Minimal structured logger for igniter-server.
-    #
-    # 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) }
-      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