nonnative 3.26.0 → 3.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59db521cea52e4a8c1d2aa8d76e79b50e7a9b76876b63ed8be4e46a665614a5d
-  data.tar.gz: 45f21fd21830aab99ce440d65d7cb80720449169684320f814a9e767881d8a1f
+  metadata.gz: d81874eb81ecd99758c560530adaf6dd701ac6136258ec36b04a074312e45e65
+  data.tar.gz: 05e90f242c9cd70a7c544705d2db49c593e7615ff7edfc28e6864154036e758b
 SHA512:
-  metadata.gz: 47d05d9b12dc2601470b87af8a880018a0be1808aee7f501f48a703db422b57db37d041b4f93fbb4ebb5afd4545bccf1ed3bf9b15b7a9d9909ca9134dc1d0111
-  data.tar.gz: 0d191245bdedd04c73096cfc4c3cd1871966c6aa9b09a1e5295c835a76798afea4633638f2d6f3bc1179d20f683484c6b033a8c655b45c047c9c468d18aa7fca
+  metadata.gz: 59abcf2ef7f4c1cf0785ab43dbca7af059441f8a65379601adc1204c8860955b462fc7fa8dac8b1bbb93cd7a449296cac36ea18bee692b67baad567b83cea3ad
+  data.tar.gz: ac4407b3205ca54a8e2496e9e2ce2594ee8bf8d7fff8f9c0ae5bce929fdf4b707732c54c8b45ccb038e79bb34601cf52823a7ee99ae6c7ae05a8bbdfb60cc05a

data/README.md

@@ -852,6 +852,7 @@ Clients connect to the service `host`/`port`, while the proxy forwards traffic t
 - `timeout` - Accepts the connection and stalls traffic until reset or stop closes the connection, so clients exercise their own read timeout behavior.
 - `invalid_data` - Forwards client requests unchanged, then corrupts upstream responses before they reach the client.
 - `bandwidth` - Throttles forwarded throughput to `options.rate` kilobytes per second (1 KB = 1024 bytes) by sleeping in proportion to the bytes read, in both directions, so clients see a slow-but-alive dependency. When `rate` is absent or not positive, traffic forwards at full speed.
+- `limit_data` - Forwards client requests unchanged, then sends the first `options.bytes` bytes of the upstream byte stream on each connection and gracefully closes the connection. When `bytes` is absent or not positive, traffic forwards at full speed.
 
 ###### 🧩 Fault Injection Services
 
@@ -864,6 +865,7 @@ service = Nonnative.pool.service_by_name(name)
 service.proxy.close_all # To use close_all.
 service.proxy.reset_peer # To reset (RST) client connections.
 service.proxy.timeout # To stall traffic until reset or stop.
+service.proxy.limit_data # To truncate the upstream byte stream at options.bytes.
 service.proxy.reset # To reset it back to a good state.
 ```
 
@@ -873,6 +875,7 @@ Use the Cucumber proxy steps:
 Given I set the proxy for service 'service_1' to 'close_all'
 Given I set the proxy for service 'service_1' to 'reset_peer'
 Given I set the proxy for service 'service_1' to 'timeout'
+Given I set the proxy for service 'service_1' to 'limit_data'
 Then I should reset the proxy for service 'service_1'
 ```
 

data/lib/nonnative/cucumber.rb

@@ -60,6 +60,7 @@ module Nonnative
         'timeout' => :timeout,
         'invalid_data' => :invalid_data,
         'bandwidth' => :bandwidth,
+        'limit_data' => :limit_data,
         'reset' => :reset
       }.freeze
 

data/lib/nonnative/fault_injection_proxy.rb

@@ -15,6 +15,7 @@ module Nonnative
   # - {#timeout}: accept connections and keep them silent until clients time out
   # - {#invalid_data}: forward requests unchanged and mutate upstream responses before they reach clients
   # - {#bandwidth}: throttle forwarded throughput to a configured rate (KB/s)
+  # - {#limit_data}: forward a configured number of response bytes, then gracefully close
   # - {#reset}: return to healthy pass-through behavior
   #
   # State changes terminate any active connections so new connections observe the new behavior.
@@ -36,6 +37,8 @@ module Nonnative
   #   - `delay`: delay duration in seconds used by {#delay}
   #   - `jitter`: optional random offset (seconds) added in `-jitter..jitter` to each `delay` (a
   #     negative value uses its magnitude), so clients see variable latency instead of a flat value
+  #   - `bytes`: positive response byte limit used by {#limit_data}; absent or non-positive values
+  #     use pass-through behavior
   #
   # @see Nonnative::Proxy
   # @see Nonnative::SocketPairFactory
@@ -150,6 +153,17 @@ module Nonnative
       apply_state :bandwidth
     end
 
+    # Truncates the upstream byte stream after a configured number of bytes.
+    #
+    # Client requests are forwarded unchanged. The response byte limit is read from
+    # `service.proxy.options[:bytes]`; when it is absent or not positive, the connection forwards at
+    # full speed without truncation.
+    #
+    # @return [void]
+    def limit_data
+      apply_state :limit_data
+    end
+
     # Resets the proxy back to healthy pass-through behavior.
     #
     # @return [void]

data/lib/nonnative/http_client.rb

@@ -92,19 +92,45 @@ module Nonnative
       end
     end
 
+    # Performs a HEAD request.
+    #
+    # @param pathname [String] path relative to `host`
+    # @param opts [Hash] RestClient request options (e.g. `headers`, `read_timeout`, `open_timeout`)
+    # @return [RestClient::Response, String] response for non-2xx errors, otherwise the RestClient result
+    def head(pathname, opts = {})
+      with_exception do
+        resource(pathname, opts).head
+      end
+    end
+
+    # Performs an OPTIONS request.
+    #
+    # @param pathname [String] path relative to `host`
+    # @param opts [Hash] RestClient request options (e.g. `headers`, `read_timeout`, `open_timeout`)
+    # @return [RestClient::Response, String] response for non-2xx errors, otherwise the RestClient result
+    def options(pathname, opts = {})
+      with_exception do
+        RestClient::Request.execute(opts.merge(method: :options, url: request_url(pathname)))
+      end
+    end
+
     # Creates a RestClient resource for a relative path.
     #
     # @param pathname [String] path relative to `host`
     # @param opts [Hash] RestClient request options
     # @return [RestClient::Resource]
     def resource(pathname, opts)
-      RestClient::Resource.new(URI.join(host, pathname).to_s, opts)
+      RestClient::Resource.new(request_url(pathname), opts)
     end
 
     private
 
     attr_reader :host, :exceptions
 
+    def request_url(pathname)
+      URI.join(host, pathname).to_s
+    end
+
     def with_exception
       yield
     rescue *exceptions => e

data/lib/nonnative/http_proxy_server.rb

@@ -22,7 +22,7 @@ module Nonnative
   #
   # The upstream host is configured via service settings (see {Nonnative::HTTPProxyServer}).
   #
-  # Supported HTTP verbs: GET, POST, PUT, PATCH, DELETE.
+  # Supported HTTP verbs: GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS.
   class HTTPProxy < Nonnative::HTTPService
     NON_FORWARDABLE_RESPONSE_HEADERS = %w[
       connection
@@ -145,7 +145,16 @@ module Nonnative
       header.delete_prefix('HTTP_').split('_').map(&:capitalize).join('-')
     end
 
-    %w[get post put patch delete].each do |verb|
+    # Registered before `get` so it takes precedence over Sinatra's GET-generated HEAD route,
+    # which would otherwise forward HEAD requests upstream as GET.
+    head(/.*/) do
+      res = api_response(method: :head, url: build_url(request, settings), headers: forward_request_headers(request))
+
+      headers(forward_response_headers(res))
+      status res.code
+    end
+
+    %w[get post put patch delete options].each do |verb|
       send(verb, /.*/) do
         res = api_response(
           method: verb.to_sym,

data/lib/nonnative/limit_data_socket_pair.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Nonnative
+  # Socket-pair variant used by the fault-injection proxy to truncate upstream responses.
+  #
+  # When active, client requests pass through unchanged, while the first `proxy.options[:bytes]`
+  # bytes of the upstream stream are forwarded to the client on each connection. Once the limit is
+  # reached, the pair's normal connection lifecycle closes both sockets gracefully. A missing or
+  # non-positive limit leaves the connection in pass-through mode.
+  #
+  # This behavior is enabled by calling {Nonnative::FaultInjectionProxy#limit_data}.
+  #
+  # @see Nonnative::FaultInjectionProxy
+  # @see Nonnative::SocketPairFactory
+  # @see Nonnative::SocketPair
+  class LimitDataSocketPair < SocketPair
+    # Tracks the client socket and response byte budget for this connection.
+    #
+    # @param local_socket [TCPSocket] the accepted client socket
+    # @return [void]
+    def connect(local_socket)
+      @local_socket = local_socket
+      @remaining = proxy.options[:bytes]
+      @limit_reached = false
+
+      super
+    ensure
+      @local_socket = nil
+      @remaining = nil
+      @limit_reached = nil
+    end
+
+    protected
+
+    # Stops the base forwarding loop after the response budget has been written.
+    #
+    # @param ready [Array<Array<IO>>] the result from `select`
+    # @param source_socket [IO] readable side
+    # @param destination_socket [IO] writable side
+    # @return [Boolean] whether the forwarding loop should terminate
+    def pipe?(ready, source_socket, destination_socket)
+      return true if @limit_reached
+
+      super || @limit_reached
+    end
+
+    # Limits writes to the client while leaving writes to the upstream unchanged.
+    #
+    # @param socket [IO] the socket to write to
+    # @param data [String] the original payload
+    # @return [Integer] number of bytes written
+    def write(socket, data)
+      return super unless socket.equal?(@local_socket)
+      return super if @remaining.nil? || @remaining <= 0
+
+      data = data.byteslice(0, @remaining)
+      @remaining -= data.bytesize
+      @limit_reached = @remaining.zero?
+
+      super
+    end
+  end
+end

data/lib/nonnative/server.rb

@@ -32,7 +32,14 @@ module Nonnative
     #   - `true` (thread creation itself is considered started; readiness is checked separately)
     def start
       unless thread
-        @thread = Thread.new { perform_start }
+        @error = nil
+        @thread = Thread.new do
+          perform_start
+        rescue StandardError => e
+          @error = e
+          raise
+        end
+        @thread.report_on_exception = true
 
         wait_start
 
@@ -61,8 +68,22 @@ module Nonnative
       object_id
     end
 
+    # Describes how the server thread terminated before becoming ready, for lifecycle diagnostics.
+    #
+    # Returns `nil` while the thread is still alive, so callers can distinguish a dead thread from a
+    # live server that merely missed its readiness window.
+    #
+    # @return [String, nil] termination detail (clean early return or uncaught exception), or `nil`
+    def termination
+      return if thread.nil? || thread.alive?
+
+      return "server thread raised #{error.class}: #{error.message}" if error
+
+      'server thread exited before readiness'
+    end
+
     private
 
-    attr_reader :thread, :timeout
+    attr_reader :thread, :timeout, :error
   end
 end

data/lib/nonnative/socket_pair_factory.rb

@@ -14,6 +14,7 @@ module Nonnative
   # - `:timeout` -> {Nonnative::TimeoutSocketPair}
   # - `:invalid_data` -> {Nonnative::InvalidDataSocketPair}
   # - `:bandwidth` -> {Nonnative::BandwidthSocketPair}
+  # - `:limit_data` -> {Nonnative::LimitDataSocketPair}
   #
   # @see Nonnative::FaultInjectionProxy
   # @see Nonnative::SocketPair
@@ -23,30 +24,28 @@ module Nonnative
   # @see Nonnative::TimeoutSocketPair
   # @see Nonnative::InvalidDataSocketPair
   # @see Nonnative::BandwidthSocketPair
+  # @see Nonnative::LimitDataSocketPair
   class SocketPairFactory
+    PAIR_BY_STATE = {
+      close_all: CloseAllSocketPair,
+      reset_peer: ResetPeerSocketPair,
+      delay: DelaySocketPair,
+      timeout: TimeoutSocketPair,
+      invalid_data: InvalidDataSocketPair,
+      bandwidth: BandwidthSocketPair,
+      limit_data: LimitDataSocketPair
+    }.freeze
+    private_constant :PAIR_BY_STATE
+
     class << self
       # Creates a socket-pair instance for the given proxy state.
       #
-      # @param kind [Symbol] proxy state (e.g. `:none`, `:close_all`, `:reset_peer`, `:delay`, `:timeout`, `:invalid_data`, `:bandwidth`)
+      # @param kind [Symbol] proxy state (e.g. `:none`, `:close_all`, `:reset_peer`, `:delay`, `:timeout`,
+      #   `:invalid_data`, `:bandwidth`, `:limit_data`)
       # @param proxy [Nonnative::ConfigurationProxy] proxy configuration (host/port/options)
       # @return [Nonnative::SocketPair] a socket-pair implementation instance
       def create(kind, proxy)
-        pair = case kind
-               when :close_all
-                 CloseAllSocketPair
-               when :reset_peer
-                 ResetPeerSocketPair
-               when :delay
-                 DelaySocketPair
-               when :timeout
-                 TimeoutSocketPair
-               when :invalid_data
-                 InvalidDataSocketPair
-               when :bandwidth
-                 BandwidthSocketPair
-               else
-                 SocketPair
-               end
+        pair = PAIR_BY_STATE.fetch(kind, SocketPair)
 
         pair.new(proxy)
       end

data/lib/nonnative/version.rb

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

data/lib/nonnative.rb

@@ -116,6 +116,7 @@ require 'nonnative/delay_socket_pair'
 require 'nonnative/timeout_socket_pair'
 require 'nonnative/invalid_data_socket_pair'
 require 'nonnative/bandwidth_socket_pair'
+require 'nonnative/limit_data_socket_pair'
 require 'nonnative/socket_pair_factory'
 require 'nonnative/go_executable'
 require 'nonnative/cucumber'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nonnative
 version: !ruby/object:Gem::Version
-  version: 3.26.0
+  version: 3.29.0
 platform: ruby
 authors:
 - Alejandro Falkowski
@@ -422,6 +422,7 @@ files:
 - lib/nonnative/http_service.rb
 - lib/nonnative/invalid_data_socket_pair.rb
 - lib/nonnative/jwt_token.rb
+- lib/nonnative/limit_data_socket_pair.rb
 - lib/nonnative/no_proxy.rb
 - lib/nonnative/not_found_error.rb
 - lib/nonnative/observability.rb