igniter 0.5.1 → 0.5.2

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

@@ -1,136 +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::Cluster::Mesh)
-
-          static  = Igniter::Cluster::Mesh.config.peers
-          dynamic = Igniter::Cluster::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),
-              "tags" => p.tags.map(&:to_s),
-              "metadata" => p.profile.metadata
-            }
-          end)
-        end
-      end
-
-      # GET /v1/mesh/sd
-      # Returns the peer list in Prometheus HTTP SD format so that Prometheus can
-      # dynamically discover all igniter-stack 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(","),
-              "__meta_igniter_tags" => peer.tags.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"], "tags": ["linux"] }
-      class MeshPeersRegisterHandler < Base
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument, Metrics/AbcSize
-          return json_error("Igniter::Cluster::Mesh is not loaded", status: 422) unless defined?(Igniter::Cluster::Mesh)
-
-          attributes = Igniter::Cluster::Mesh::PeerIdentityEnvelope.build(
-            source: body,
-            trust_store: Igniter::Cluster::Mesh.config.trust_store
-          )
-
-          name = attributes[:name].to_s.strip
-          url = attributes[: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?
-
-          peer = Igniter::Cluster::Mesh::Peer.new(
-            name: name,
-            url: url,
-            capabilities: attributes[:capabilities] || [],
-            tags: attributes[:tags] || [],
-            metadata: attributes[:metadata] || {}
-          )
-          Igniter::Cluster::Mesh.config.peer_registry.register(peer)
-
-          json_ok({
-                    "registered" => true,
-                    "name" => name,
-                    "trust" => peer.metadata.dig(:mesh_trust, :status)&.to_s
-                  })
-        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::Cluster::Mesh is not loaded", status: 422) unless defined?(Igniter::Cluster::Mesh)
-
-          name = params[:name].to_s
-          Igniter::Cluster::Mesh.config.peer_registry.unregister(name)
-
-          json_ok({ "unregistered" => true, "name" => name })
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/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/packages/igniter-server/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/packages/igniter-server/lib/igniter/server/http_server.rb

@@ -1,222 +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",
-        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/packages/igniter-server/lib/igniter/server/rack_app.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    # Rack-compatible application adapter.
-    # Allows igniter-stack 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)
-        config.logger ||= ServerLogger.new(format: config.log_format)
-        @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, headers: request_headers(env), env: env)
-
-        if result[:stream]
-          return [
-            result[:status],
-            result[:headers],
-            result[:body]
-          ]
-        end
-
-        [
-          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
-
-      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/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/packages/igniter-server/lib/igniter/server/remote_adapter.rb

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