nonnative 3.30.0 → 3.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 954eb6b4c3c122729406d275f3befa59e19b8db405e14cb2ee8fd759354f97ba
-  data.tar.gz: 39291c978f15b62b187aeb51b5d51f8b0479d314261f1eaab85e6d9f441b3a54
+  metadata.gz: 108231da69ec8bdf5cd71d3b0a2bb1e724c7b7826a3c33b631044873d2de71cb
+  data.tar.gz: 43b4fb6617eebce09db0b460aa0ad8117290a5a8f952eccbe33f8fbe89ad6766
 SHA512:
-  metadata.gz: f2a6efd54e9af260f1e0261347e0f2d93825392833bbbc8818e073dfd13359eb3739afa8bd535fea01e502fbe3d0664abbae49b41eb17fed1531c1a19019e0f1
-  data.tar.gz: 3b6f5e46899a77d275500d7d5edca75a46f739db103d7b006ca8cbe8699a24edc362679226ba7e67221dd2fb1cc200e09c4c366b9b3faa8a42fa17be61b9b246
+  metadata.gz: 7c9446f51fe18cd021c0baa25d0de2ab3389c01e3d1ec571decc3855c711737012cc5268f42acac6b604f9b9aa7bb957ce5197caf74d8150bf0e395291de78e3
+  data.tar.gz: 1b4ce6b1bb74f9952f93f66d8064ae90f66108e7fb2038f35e4d52e4dcfe02b40c58469402883c2bd737246d35eb4a44a132b8033a2aa06980e2d7baff580a29

data/README.md

@@ -276,8 +276,8 @@ The shipped steps are compatibility surface for downstream suites:
   text: `Then I should see a log entry of {string} for process {string}` and
   `Then I should see a log entry of {string} in the file {string}`.
 - `Given I set the proxy for service {string} to {string}` accepts `close_all`, `reset_peer`, `delay`,
-  `timeout`, `invalid_data`, `bandwidth`, `limit_data`, or `reset`; the reset action step is
-  `Then I should reset the proxy for service {string}`.
+  `timeout`, `invalid_data`, `bandwidth`, `limit_data`, `slicer`, `flaky`, or `reset`; the reset action
+  step is `Then I should reset the proxy for service {string}`.
 
 ```cucumber
 @manual
@@ -597,9 +597,11 @@ end
 
 The system allows you to define an in-process HTTP forward proxy server for external systems, e.g. `api.github.com`. This is a server implementation, not a fault-injection service proxy.
 
-The upstream scheme is always HTTPS. The proxy forwards the request path and query for `GET`, `HEAD`,
-`POST`, `PUT`, `PATCH`, `DELETE`, and `OPTIONS`, while removing proxy credentials plus `Host` and
-`Accept-Encoding` before the upstream request.
+The upstream scheme defaults to HTTPS on the scheme's default port; pass `scheme:`/`port:` to
+`Nonnative::HTTPProxyServer.new` to target an `http://` upstream or a non-default port. The proxy
+forwards the request path and query for `GET`, `HEAD`, `POST`, `PUT`, `PATCH`, `DELETE`, and
+`OPTIONS`, while removing proxy credentials plus `Host` and `Accept-Encoding` before the upstream
+request.
 
 The proxy preserves the upstream status, body, and safe end-to-end response headers such as `Content-Type`, `ETag`, and application-specific metadata. It removes hop-by-hop, connection-nominated, proxy-authentication, and framing headers; `Set-Cookie`, `Location`, and `Content-Encoding` are not forwarded.
 
@@ -932,6 +934,8 @@ Clients connect to the service `host`/`port`, while the proxy forwards traffic t
 - `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.
+- `slicer` - Forwards client requests unchanged, then writes each response to the client in `options.slice_size`-byte pieces, optionally separated by `options.slice_delay` seconds, so a client must perform multiple reads to reassemble the message. When `slice_size` is absent or not positive, traffic forwards at full speed.
+- `flaky` - Fails a fraction of new connections (closed immediately, like `close_all`) controlled by `options.probability` (0.0-1.0), forwarding the rest normally, so a client's retry/reconnect logic sees both failures and successes while this state stays active. When `probability` is absent or not positive, traffic forwards at full speed.
 
 ###### 🧩 Fault Injection Services
 

data/lib/nonnative/cucumber.rb

@@ -61,6 +61,8 @@ module Nonnative
         'invalid_data' => :invalid_data,
         'bandwidth' => :bandwidth,
         'limit_data' => :limit_data,
+        'slicer' => :slicer,
+        'flaky' => :flaky,
         'reset' => :reset
       }.freeze
 

data/lib/nonnative/fault_injection_proxy.rb

@@ -16,6 +16,8 @@ module Nonnative
   # - {#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
+  # - {#slicer}: forward responses to the client in small writes to force multi-`recv` reassembly
+  # - {#flaky}: fail a configurable fraction of new connections, forwarding the rest normally
   # - {#reset}: return to healthy pass-through behavior
   #
   # State changes terminate any active connections so new connections observe the new behavior.
@@ -41,6 +43,11 @@ module Nonnative
   #     values forward at full speed
   #   - `bytes`: positive response byte limit used by {#limit_data}; absent or non-positive values
   #     use pass-through behavior
+  #   - `slice_size`: positive response slice size (bytes) used by {#slicer}; absent or non-positive
+  #     values use pass-through behavior
+  #   - `slice_delay`: optional delay (seconds) between slices used by {#slicer}
+  #   - `probability`: connection failure fraction (0.0-1.0) used by {#flaky}; absent or non-positive
+  #     values use pass-through behavior
   #
   # @see Nonnative::Proxy
   # @see Nonnative::SocketPairFactory
@@ -91,6 +98,10 @@ module Nonnative
       server&.close
 
       listener_thread = thread
+      # Closing the server is meant to wake the blocked `accept`, but a concurrently blocked
+      # `accept` is not reliably interrupted by `close` on every platform. Kill the listener so
+      # `stop` cannot hang joining an accept loop that never woke (a no-op once it has exited).
+      listener_thread&.kill
       listener_thread&.join
 
       @tcp_server = nil
@@ -166,6 +177,31 @@ module Nonnative
       apply_state :limit_data
     end
 
+    # Fragments upstream responses into small writes before forwarding to the client.
+    #
+    # Client requests are forwarded unchanged. Each response is split into
+    # `service.proxy.options[:slice_size]`-byte writes, optionally separated by
+    # `service.proxy.options[:slice_delay]` seconds, so a client's `recv` returns a strict prefix of
+    # the response rather than the whole message. When `slice_size` is absent or not positive, the
+    # connection forwards at full speed without slicing.
+    #
+    # @return [void]
+    def slicer
+      apply_state :slicer
+    end
+
+    # Fails a configurable fraction of new connections while forwarding the rest normally.
+    #
+    # The fraction is controlled by `service.proxy.options[:probability]` (0.0-1.0); absent or
+    # non-positive values behave like pass-through, and `1.0` fails every connection. Because each
+    # connection decides independently, clients that retry/reconnect can observe both failures and
+    # successes while this state stays active.
+    #
+    # @return [void]
+    def flaky
+      apply_state :flaky
+    end
+
     # Resets the proxy back to healthy pass-through behavior.
     #
     # @return [void]

data/lib/nonnative/flaky_socket_pair.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Nonnative
+  # Socket-pair variant used by the fault-injection proxy to simulate a flapping dependency.
+  #
+  # When active, each new connection independently fails with probability
+  # `proxy.options[:probability]` (closed immediately, like {Nonnative::CloseAllSocketPair}) and
+  # otherwise forwards normally. Because the decision is made per connection rather than per state, a
+  # client that retries/reconnects can observe some attempts fail and others succeed while this fault
+  # state stays active, exercising retry/reconnect/circuit-breaker recovery rather than a fully down
+  # dependency. A missing or non-positive `probability` behaves like pass-through; `probability >= 1.0`
+  # fails every connection.
+  #
+  # This behavior is enabled by calling {Nonnative::FaultInjectionProxy#flaky}.
+  #
+  # @see Nonnative::FaultInjectionProxy
+  # @see Nonnative::SocketPairFactory
+  # @see Nonnative::SocketPair
+  # @see Nonnative::CloseAllSocketPair
+  class FlakySocketPair < SocketPair
+    # Fails the connection with the configured probability, otherwise forwards it normally.
+    #
+    # @param local_socket [TCPSocket] the accepted client socket
+    # @return [void]
+    def connect(local_socket)
+      return super unless fail?
+
+      Nonnative.logger.info "closing socket '#{local_socket.inspect}' for 'flaky' pair"
+
+      local_socket.close
+    end
+
+    private
+
+    # Decides whether this connection should fail, based on `proxy.options[:probability]`.
+    #
+    # @return [Boolean]
+    def fail?
+      probability = proxy.options[:probability]
+      return false if probability.nil? || probability <= 0
+
+      rand < probability
+    end
+  end
+end

data/lib/nonnative/http_proxy_server.rb

@@ -2,8 +2,9 @@
 
 # Sinatra-based HTTP forward proxy server used as an in-process Nonnative server.
 #
-# The proxy receives inbound HTTP requests and forwards them to an upstream host over HTTPS, returning
-# the upstream response status, body, and safe end-to-end response headers. Hop-by-hop,
+# The proxy receives inbound HTTP requests and forwards them to an upstream host, defaulting to HTTPS
+# on the scheme's default port but configurable to HTTP and/or a non-default port. It returns the
+# upstream response status, body, and safe end-to-end response headers. Hop-by-hop,
 # connection-nominated, proxy-authentication, framing, and deferred response headers are not forwarded.
 #
 # This file defines two classes:
@@ -69,10 +70,12 @@ module Nonnative
     # Builds the upstream URL for the given request.
     #
     # @param request [Sinatra::Request] the incoming request
-    # @param settings [Sinatra::Base] Sinatra settings, expected to include `host`
-    # @return [String] HTTPS URL for the upstream request
+    # @param settings [Sinatra::Base] Sinatra settings, expected to include `host`, `scheme`, and `port`
+    # @return [String] upstream URL
     def build_url(request, settings)
-      URI::HTTPS.build(host: settings.host, path: request.path_info, query: request.query_string).to_s
+      uri_class = settings.scheme == 'http' ? URI::HTTP : URI::HTTPS
+
+      uri_class.build(host: settings.host, port: settings.port, path: request.path_info, query: request.query_string).to_s
     end
 
     # Executes the upstream request and returns the response.
@@ -193,11 +196,15 @@ module Nonnative
   #
   # @see Nonnative::HTTPServer
   class HTTPProxyServer < Nonnative::HTTPServer
-    # @param host [String] upstream host to proxy to (HTTPS)
+    # @param host [String] upstream host to proxy to
     # @param service [Nonnative::ConfigurationServer] server configuration
-    def initialize(host, service)
+    # @param scheme [String] upstream scheme, `"http"` or `"https"`
+    # @param port [Integer, nil] upstream port; `nil` uses the scheme's default port
+    def initialize(host, service, scheme: 'https', port: nil)
       http_service = Class.new(Nonnative::HTTPProxy) do
         set :host, host
+        set :scheme, scheme
+        set :port, port
       end
 
       super(http_service.new, service)

data/lib/nonnative/slicer_socket_pair.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Nonnative
+  # Socket-pair variant used by the fault-injection proxy to fragment upstream responses.
+  #
+  # When active, client requests pass through unchanged, while each response written back to the
+  # client is split into `proxy.options[:slice_size]`-byte writes, optionally separated by
+  # `proxy.options[:slice_delay]` seconds, so a client that assumes one `recv` yields a whole protocol
+  # frame is forced to perform multiple reads and reassemble the message. A missing or non-positive
+  # `slice_size` leaves the connection in pass-through mode.
+  #
+  # This behavior is enabled by calling {Nonnative::FaultInjectionProxy#slicer}.
+  #
+  # @see Nonnative::FaultInjectionProxy
+  # @see Nonnative::SocketPairFactory
+  # @see Nonnative::SocketPair
+  class SlicerSocketPair < SocketPair
+    # Tracks the client socket so we can fragment only the response path.
+    #
+    # @param local_socket [TCPSocket] the accepted client socket
+    # @return [void]
+    def connect(local_socket)
+      @local_socket = local_socket
+
+      super
+    ensure
+      @local_socket = nil
+    end
+
+    # Writes response data to the client in configured slices, leaving requests 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)
+
+      size = proxy.options[:slice_size]
+      return super if size.nil? || size <= 0
+
+      sliced_write(socket, data, size)
+    end
+
+    private
+
+    # Writes `data` to `socket` in `size`-byte slices, sleeping `proxy.options[:slice_delay]` seconds
+    # between slices (when positive) to help defeat TCP write coalescing.
+    #
+    # @param socket [IO] the socket to write to
+    # @param data [String] the original payload
+    # @param size [Integer] the slice size in bytes
+    # @return [Integer] number of bytes written
+    def sliced_write(socket, data, size)
+      delay = proxy.options[:slice_delay]
+      offset = 0
+      written = 0
+
+      while offset < data.bytesize
+        chunk = data.byteslice(offset, size)
+        written += socket.write(chunk)
+        offset += chunk.bytesize
+
+        sleep(delay) if delay&.positive? && offset < data.bytesize
+      end
+
+      written
+    end
+  end
+end

data/lib/nonnative/socket_pair_factory.rb

@@ -15,6 +15,8 @@ module Nonnative
   # - `:invalid_data` -> {Nonnative::InvalidDataSocketPair}
   # - `:bandwidth` -> {Nonnative::BandwidthSocketPair}
   # - `:limit_data` -> {Nonnative::LimitDataSocketPair}
+  # - `:slicer` -> {Nonnative::SlicerSocketPair}
+  # - `:flaky` -> {Nonnative::FlakySocketPair}
   #
   # @see Nonnative::FaultInjectionProxy
   # @see Nonnative::SocketPair
@@ -25,6 +27,8 @@ module Nonnative
   # @see Nonnative::InvalidDataSocketPair
   # @see Nonnative::BandwidthSocketPair
   # @see Nonnative::LimitDataSocketPair
+  # @see Nonnative::SlicerSocketPair
+  # @see Nonnative::FlakySocketPair
   class SocketPairFactory
     PAIR_BY_STATE = {
       close_all: CloseAllSocketPair,
@@ -33,7 +37,9 @@ module Nonnative
       timeout: TimeoutSocketPair,
       invalid_data: InvalidDataSocketPair,
       bandwidth: BandwidthSocketPair,
-      limit_data: LimitDataSocketPair
+      limit_data: LimitDataSocketPair,
+      slicer: SlicerSocketPair,
+      flaky: FlakySocketPair
     }.freeze
     private_constant :PAIR_BY_STATE
 
@@ -41,7 +47,7 @@ module Nonnative
       # 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`, `:limit_data`)
+      #   `:invalid_data`, `:bandwidth`, `:limit_data`, `:slicer`, `:flaky`)
       # @param proxy [Nonnative::ConfigurationProxy] proxy configuration (host/port/options)
       # @return [Nonnative::SocketPair] a socket-pair implementation instance
       def create(kind, proxy)

data/lib/nonnative/version.rb

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

data/lib/nonnative.rb

@@ -117,6 +117,8 @@ require 'nonnative/timeout_socket_pair'
 require 'nonnative/invalid_data_socket_pair'
 require 'nonnative/bandwidth_socket_pair'
 require 'nonnative/limit_data_socket_pair'
+require 'nonnative/slicer_socket_pair'
+require 'nonnative/flaky_socket_pair'
 require 'nonnative/socket_pair_factory'
 require 'nonnative/go_executable'
 require 'nonnative/cucumber'
@@ -349,10 +351,11 @@ module Nonnative
 
     # Resets proxies for all currently started runners.
     #
+    # No-op when called before {Nonnative.start}, since no pool exists yet.
+    #
     # @return [void]
-    # @raise [NoMethodError] if called before {Nonnative.start} (because {Nonnative.pool} is nil)
     def reset
-      Nonnative.pool.reset
+      Nonnative.pool&.reset
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nonnative
 version: !ruby/object:Gem::Version
-  version: 3.30.0
+  version: 3.32.0
 platform: ruby
 authors:
 - Alejandro Falkowski
@@ -410,6 +410,7 @@ files:
 - lib/nonnative/ed25519_key.rb
 - lib/nonnative/error.rb
 - lib/nonnative/fault_injection_proxy.rb
+- lib/nonnative/flaky_socket_pair.rb
 - lib/nonnative/go_executable.rb
 - lib/nonnative/grpc_health.rb
 - lib/nonnative/grpc_probe.rb
@@ -437,6 +438,7 @@ files:
 - lib/nonnative/runner.rb
 - lib/nonnative/server.rb
 - lib/nonnative/service.rb
+- lib/nonnative/slicer_socket_pair.rb
 - lib/nonnative/socket_pair.rb
 - lib/nonnative/socket_pair_factory.rb
 - lib/nonnative/ssh_token.rb
@@ -470,7 +472,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.11
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Ruby-first end-to-end harness for testing systems implemented in other languages
 test_files: []