nonnative 2.0 → 2.8.0

data/lib/nonnative/configuration_proxy.rb

@@ -20,7 +20,8 @@ module Nonnative
     # @return [String, nil] path to proxy log file (implementation-dependent)
     # @return [Numeric] wait interval (seconds) after proxy state changes (defaults to `0.1`)
     # @return [Hash] proxy implementation options (implementation-dependent)
-    attr_accessor :kind, :host, :port, :log, :wait, :options
+    attr_accessor :kind, :host, :port, :log, :wait
+    attr_reader :options
 
     # Creates a proxy configuration with defaults.
     #
@@ -39,5 +40,16 @@ module Nonnative
       self.wait = 0.1
       self.options = {}
     end
+
+    # Stores proxy implementation options.
+    #
+    # Nil is normalized to an empty hash so callers loading partial configuration do not erase the
+    # default options container.
+    #
+    # @param value [Hash, nil]
+    # @return [void]
+    def options=(value)
+      @options = value || {}
+    end
   end
 end

data/lib/nonnative/cucumber.rb

@@ -1,105 +1,201 @@
 # frozen_string_literal: true
 
-World(RSpec::Benchmark::Matchers)
-World(RSpec::Matchers)
-World(RSpec::Wait)
-
-Before('@startup') do
-  Nonnative.start
-end
-
-After('@startup') do
-  Nonnative.stop
-end
-
-After('@manual') do
-  Nonnative.stop
-end
-
-Before('@clear') do
-  Nonnative.clear
-end
-
-After('@reset') do
-  Nonnative.reset
-end
-
-Given('I set the proxy for process {string} to {string}') do |name, operation|
-  process = Nonnative.pool.process_by_name(name)
-  process.proxy.send(operation)
-end
-
-Given('I set the proxy for server {string} to {string}') do |name, operation|
-  server = Nonnative.pool.server_by_name(name)
-  server.proxy.send(operation)
-end
-
-Given('I set the proxy for service {string} to {string}') do |name, operation|
-  service = Nonnative.pool.service_by_name(name)
-  service.proxy.send(operation)
-end
-
-Given('I start the system') do
-  Nonnative.start
-end
-
-Given('I should see {string} as unhealthy') do |service|
-  opts = {
-    headers: { content_type: :json, accept: :json },
-    read_timeout: 10, open_timeout: 10
-  }
-
-  wait_for { Nonnative.observability.health(opts).code }.to eq(503)
-  wait_for { Nonnative.observability.health(opts).body }.to include(service)
-end
-
-Then('I should reset the proxy for process {string}') do |name|
-  process = Nonnative.pool.process_by_name(name)
-  process.proxy.reset
-end
-
-Then('I should reset the proxy for server {string}') do |name|
-  server = Nonnative.pool.server_by_name(name)
-  server.proxy.reset
-end
-
-Then('I should reset the proxy for service {string}') do |name|
-  service = Nonnative.pool.service_by_name(name)
-  service.proxy.reset
-end
-
-Then('the process {string} should consume less than {string} of memory') do |name, mem|
-  process = Nonnative.pool.process_by_name(name)
-  _, size, type = mem.split(/(\d+)/)
-  actual = process.memory.send(type)
-  size = size.to_i
-
-  expect(actual).to be < size
-end
-
-Then('starting the system should raise an error') do
-  expect { Nonnative.start }.to raise_error(Nonnative::StartError)
-end
-
-Then('stopping the system should raise an error') do
-  expect { Nonnative.stop }.to raise_error(Nonnative::StopError)
-end
-
-Then('I should see a log entry of {string} for process {string}') do |message, process|
-  process = Nonnative.configuration.process_by_name(process)
-  expect(Nonnative.log_lines(process.log, ->(l) { l.include?(message) }).first).to include(message)
-end
-
-Then('I should see a log entry of {string} in the file {string}') do |message, path|
-  expect(Nonnative.log_lines(path, ->(l) { l.include?(message) }).first).to include(message)
-end
-
-Then('I should see {string} as healthy') do |service|
-  opts = {
-    headers: { content_type: :json, accept: :json },
-    read_timeout: 10, open_timeout: 10
-  }
-
-  wait_for { Nonnative.observability.health(opts).code }.to eq(200)
-  wait_for { Nonnative.observability.health(opts).body }.to_not include(service)
-end
+require 'cucumber'
+
+module Nonnative
+  # Lazily installs the Cucumber integration once the Cucumber Ruby DSL is ready.
+  #
+  # Requiring `nonnative` outside a running Cucumber environment should not fail, but when Cucumber
+  # does finish booting its support-code registry this installer still needs to register the hooks
+  # and step definitions defined here.
+  module Cucumber
+    module LanguageHook
+      def rb_language=(value)
+        super.tap { ::Nonnative::Cucumber.install! }
+      end
+    end
+
+    module WorldHooks
+      def install_world
+        World(::RSpec::Benchmark::Matchers)
+        World(::RSpec::Matchers)
+        World(::RSpec::Wait)
+      end
+
+      def install_hooks
+        Before('@startup') { Nonnative.start }
+        After('@startup') { Nonnative.stop }
+        After('@manual') { Nonnative.stop }
+        Before('@clear') { Nonnative.clear }
+        After('@reset') { Nonnative.reset }
+      end
+    end
+
+    module ProxySteps
+      def install_proxy_steps
+        install_proxy_mutation_steps
+        install_proxy_reset_steps
+      end
+
+      def install_proxy_mutation_steps
+        Given('I set the proxy for process {string} to {string}') do |name, operation|
+          process = Nonnative.pool.process_by_name(name)
+          process.proxy.send(operation)
+        end
+
+        Given('I set the proxy for server {string} to {string}') do |name, operation|
+          server = Nonnative.pool.server_by_name(name)
+          server.proxy.send(operation)
+        end
+
+        Given('I set the proxy for service {string} to {string}') do |name, operation|
+          service = Nonnative.pool.service_by_name(name)
+          service.proxy.send(operation)
+        end
+      end
+
+      def install_proxy_reset_steps
+        Then('I should reset the proxy for process {string}') do |name|
+          process = Nonnative.pool.process_by_name(name)
+          process.proxy.reset
+        end
+
+        Then('I should reset the proxy for server {string}') do |name|
+          server = Nonnative.pool.server_by_name(name)
+          server.proxy.reset
+        end
+
+        Then('I should reset the proxy for service {string}') do |name|
+          service = Nonnative.pool.service_by_name(name)
+          service.proxy.reset
+        end
+      end
+    end
+
+    module LifecycleSteps
+      def install_state_steps
+        install_start_step
+        install_unhealthy_step
+        install_healthy_step
+      end
+
+      def install_start_step
+        Given('I start the system') do
+          Nonnative.start
+        end
+      end
+
+      def install_unhealthy_step
+        opts = observability_options
+
+        Given('I should see {string} as unhealthy') do |service|
+          wait_for { Nonnative.observability.health(opts).code }.to eq(503)
+          wait_for { Nonnative.observability.health(opts).body }.to include(service)
+        end
+      end
+
+      def install_healthy_step
+        opts = observability_options
+
+        Then('I should see {string} as healthy') do |service|
+          wait_for { Nonnative.observability.health(opts).code }.to eq(200)
+          wait_for { Nonnative.observability.health(opts).body }.to_not include(service)
+        end
+      end
+
+      def observability_options
+        {
+          headers: { content_type: :json, accept: :json },
+          read_timeout: 10,
+          open_timeout: 10
+        }
+      end
+    end
+
+    module Assertions
+      def install_assertion_steps
+        install_memory_assertion_step
+        install_error_assertion_steps
+        install_log_assertion_steps
+      end
+
+      def install_memory_assertion_step
+        Then('the process {string} should consume less than {string} of memory') do |name, mem|
+          process = Nonnative.pool.process_by_name(name)
+          _, size, type = mem.split(/(\d+)/)
+          actual = process.memory.send(type)
+          size = size.to_i
+
+          expect(actual).to be < size
+        end
+      end
+
+      def install_error_assertion_steps
+        Then('starting the system should raise an error') do
+          expect { Nonnative.start }.to raise_error(Nonnative::StartError)
+        end
+
+        Then('stopping the system should raise an error') do
+          expect { Nonnative.stop }.to raise_error(Nonnative::StopError)
+        end
+      end
+
+      def install_log_assertion_steps
+        Then('I should see a log entry of {string} for process {string}') do |message, process|
+          process = Nonnative.configuration.process_by_name(process)
+          expect(Nonnative.log_lines(process.log, ->(l) { l.include?(message) }).first).to include(message)
+        end
+
+        Then('I should see a log entry of {string} in the file {string}') do |message, path|
+          expect(Nonnative.log_lines(path, ->(l) { l.include?(message) }).first).to include(message)
+        end
+      end
+    end
+
+    module Registration
+      extend ::Cucumber::Glue::Dsl
+      extend WorldHooks
+      extend ProxySteps
+      extend LifecycleSteps
+      extend Assertions
+
+      class << self
+        def install!
+          install_world
+          install_hooks
+          install_proxy_steps
+          install_state_steps
+          install_assertion_steps
+        end
+      end
+    end
+
+    class << self
+      def bootstrap!
+        return if @bootstrapped
+
+        dsl_singleton = ::Cucumber::Glue::Dsl.singleton_class
+        dsl_singleton.prepend(LanguageHook) unless dsl_singleton.ancestors.include?(LanguageHook)
+
+        @bootstrapped = true
+        install!
+      end
+
+      def install!
+        return if @installed
+        return unless ready?
+
+        Registration.install!
+        @installed = true
+      end
+
+      private
+
+      def ready?
+        !::Cucumber::Glue::Dsl.instance_variable_get(:@rb_language).nil?
+      end
+    end
+  end
+end
+
+Nonnative::Cucumber.bootstrap!

data/lib/nonnative/http_proxy_server.rb

@@ -30,10 +30,11 @@ module Nonnative
     # @param request [Sinatra::Request] the incoming request
     # @return [Hash{String=>String}] headers to forward to the upstream
     def retrieve_headers(request)
-      headers = request.env.map do |header, value|
-        [header[5..].split('_').map(&:capitalize).join('-'), value] if header.start_with?('HTTP_')
+      headers = request.env.each_with_object({}) do |(header, value), result|
+        next unless forward_header?(header)
+
+        result[normalized_header_name(header)] = value
       end
-      headers = headers.compact.to_h
 
       headers.except('Host', 'Accept-Encoding', 'Version')
     end
@@ -53,19 +54,45 @@ module Nonnative
     # @param uri [String] upstream URI
     # @param opts [Hash] RestClient options (e.g. headers)
     # @return [RestClient::Response] response for error statuses, otherwise RestClient return value
-    def api_response(verb, uri, opts)
-      client = RestClient::Resource.new(uri, opts)
+    def api_response(method:, url:, headers:, payload: nil)
+      options = { method:, url:, headers: }
+      options[:payload] = payload unless payload.nil?
 
-      client.send(verb)
+      RestClient::Request.execute(options)
     rescue RestClient::Exception => e
       e.response
     end
 
+    # Extracts the request payload for verbs that can carry a body.
+    #
+    # @param request [Sinatra::Request] the incoming request
+    # @param verb [String] HTTP verb name (e.g. `"post"`)
+    # @return [String, nil] request payload for body-carrying verbs
+    def retrieve_payload(request, verb)
+      return unless %w[post put patch delete].include?(verb)
+
+      payload = request.body.read
+      payload unless payload.empty?
+    end
+
+    private
+
+    def forward_header?(header)
+      header.start_with?('HTTP_') || %w[CONTENT_TYPE CONTENT_LENGTH].include?(header)
+    end
+
+    def normalized_header_name(header)
+      header.delete_prefix('HTTP_').split('_').map(&:capitalize).join('-')
+    end
+
     %w[get post put patch delete].each do |verb|
       send(verb, /.*/) do
-        uri = build_url(request, settings)
-        opts = { headers: retrieve_headers(request) }
-        res = api_response(verb, uri, opts)
+        res = api_response(
+          method: verb.to_sym,
+          url: build_url(request, settings),
+          headers: retrieve_headers(request),
+          payload: retrieve_payload(request, verb)
+        )
 
         status res.code
         res.body

data/lib/nonnative/pool.rb

@@ -18,6 +18,9 @@ module Nonnative
     # @param configuration [Nonnative::Configuration] the configuration to run
     def initialize(configuration)
       @configuration = configuration
+      @services = nil
+      @servers = nil
+      @processes = nil
     end
 
     # Starts all configured runners and yields results for each process/server.
@@ -27,10 +30,14 @@ module Nonnative
     # @yieldparam name [String, nil] runner name
     # @yieldparam values [Object] runner-specific return value from `start` (e.g. `[pid, running]` for processes)
     # @yieldparam result [Boolean] result of the port readiness check (`true` if ready in time)
-    # @return [void]
+    # @return [Array<String>] lifecycle and readiness-check errors collected while starting
     def start(&)
-      services.each(&:start)
-      [servers, processes].each { |t| process(t, :start, :open?, &) }
+      errors = []
+
+      errors.concat(service_lifecycle(services, :start, :start))
+      [servers, processes].each { |t| errors.concat(process(t, :start, :open?, :start, &)) }
+
+      errors
     end
 
     # Stops all configured runners and yields results for each process/server.
@@ -40,10 +47,32 @@ module Nonnative
     # @yieldparam name [String, nil] runner name
     # @yieldparam id [Object] runner-specific identifier returned by `stop` (e.g. pid or object_id)
     # @yieldparam result [Boolean] result of the port shutdown check (`true` if closed in time)
-    # @return [void]
+    # @return [Array<String>] lifecycle and shutdown-check errors collected while stopping
     def stop(&)
-      [processes, servers].each { |t| process(t, :stop, :closed?, &) }
-      services.each(&:stop)
+      errors = []
+
+      [processes, servers].each { |t| errors.concat(process(t, :stop, :closed?, :stop, &)) }
+      errors.concat(service_lifecycle(services, :stop, :stop))
+
+      errors
+    end
+
+    # Stops only runners that have already been instantiated in this pool.
+    #
+    # This is used to rollback partial startup after a failed {#start} without constructing new runner
+    # wrappers as a side effect.
+    #
+    # @yieldparam name [String, nil] runner name
+    # @yieldparam id [Object] runner-specific identifier returned by `stop`
+    # @yieldparam result [Boolean] result of the port shutdown check (`true` if closed in time)
+    # @return [Array<String>] lifecycle and shutdown-check errors collected while rolling back
+    def rollback(&)
+      errors = []
+
+      [existing_processes, existing_servers].each { |t| errors.concat(process(t, :stop, :closed?, :stop, &)) }
+      errors.concat(service_lifecycle(existing_services, :stop, :stop))
+
+      errors
     end
 
     # Finds a running process runner by configured name.
@@ -96,41 +125,103 @@ module Nonnative
     end
 
     def processes
-      @processes ||= configuration.processes.map do |p|
-        [Nonnative::Process.new(p), Nonnative::Port.new(p)]
+      return @processes unless @processes.nil?
+
+      @processes = []
+      configuration.processes.each do |p|
+        @processes << [Nonnative::Process.new(p), Nonnative::Port.new(p)]
       end
+
+      @processes
     end
 
     def servers
-      @servers ||= configuration.servers.map do |s|
-        [s.klass.new(s), Nonnative::Port.new(s)]
+      return @servers unless @servers.nil?
+
+      @servers = []
+      configuration.servers.each do |s|
+        @servers << [s.klass.new(s), Nonnative::Port.new(s)]
       end
+
+      @servers
     end
 
     def services
-      @services ||= configuration.services.map { |s| Nonnative::Service.new(s) }
+      return @services unless @services.nil?
+
+      @services = []
+      configuration.services.each do |s|
+        @services << Nonnative::Service.new(s)
+      end
+
+      @services
+    end
+
+    def existing_processes
+      @processes || []
+    end
+
+    def existing_servers
+      @servers || []
+    end
+
+    def existing_services
+      @services || []
     end
 
-    def process(all, type_method, port_method, &)
-      types = []
-      pids = []
-      threads = []
+    def service_lifecycle(all, type_method, action)
+      all.each_with_object([]) do |service, errors|
+        service.send(type_method)
+      rescue StandardError => e
+        errors << lifecycle_error(action, service, e)
+      end
+    end
+
+    def process(all, type_method, port_method, action, &)
+      checks = []
+      errors = []
 
       all.each do |type, port|
-        types << type
-        pids << type.send(type_method)
-        threads << Thread.new { port.send(port_method) }
+        values = type.send(type_method)
+        checks << [type, values, Thread.new { check_port(port, port_method) }]
+      rescue StandardError => e
+        errors << lifecycle_error(action, type, e)
       end
 
-      ports = threads.map(&:value)
+      errors.concat(yield_results(checks, action, &))
+    end
 
-      yield_results(types, pids, ports, &)
+    def check_port(port, port_method)
+      { result: port.send(port_method) }
+    rescue StandardError => e
+      { error: e }
     end
 
-    def yield_results(all, pids, ports)
-      all.zip(pids, ports).each do |type, values, result|
-        yield type.name, values, result
+    def yield_results(checks, action, &)
+      checks.each_with_object([]) do |(type, values, thread), errors|
+        result = thread.value
+        if result[:error]
+          errors << port_error(action, type, result[:error])
+        elsif block_given?
+          yield type.name, values, result[:result]
+        end
       end
     end
+
+    def lifecycle_error(action, type, error)
+      "#{action.to_s.capitalize} failed for #{runner_name(type)}: #{error.class} - #{error.message}"
+    end
+
+    def port_error(action, type, error)
+      check = action == :start ? 'readiness' : 'shutdown'
+      "#{check.capitalize} check failed for #{runner_name(type)}: #{error.class} - #{error.message}"
+    end
+
+    def runner_name(type)
+      name = type.name
+      return "runner '#{name}'" if name
+
+      type.class.to_s
+    end
   end
 end

data/lib/nonnative/process.rb

@@ -45,11 +45,12 @@ module Nonnative
     def stop
       if process_exists?
         process_kill
-        proxy.stop
         wait_stop
       end
 
       pid
+    ensure
+      proxy.stop
     end
 
     # Returns a memoized memory reader for the spawned process.

data/lib/nonnative/version.rb

@@ -4,5 +4,5 @@ module Nonnative
   # The current gem version.
   #
   # @return [String]
-  VERSION = '2.0'
+  VERSION = '2.8.0'
 end