httpx 1.8.4 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: daca70f040a0f0afcc413a6eb3b2e586ae56a5405477c0045cf226aaddf5b49c
-  data.tar.gz: 53910e19b4bf264a2d3cf4aed4298de57c4c6373f868e3d9e187140c15f2ed63
+  metadata.gz: 8eaea3d273dcba77ecae2abaf1979fa7ebbfddadf5c8f67b71636aac594b12e6
+  data.tar.gz: d4e50760994c7dff6d7ae963427f721ce349add9455055e01fc7074b2a9350ed
 SHA512:
-  metadata.gz: 8b19e3219fb672bfbb45c4e5427c68b9f7ba715003f5b39796a2314bd8b991b58c5bc185767e303557159f04d61d84c19523f25b953b604a74753e55859defb8
-  data.tar.gz: 844bf656335bdbc5599003d6ee9724ff54b05478bfa9de37d5e251acff788154d4d7cea4b866b56c7d4c42d07b1afa8ece6982b02c5236d981843f092ee25ceb
+  metadata.gz: ae04971cb261d34dd72b1cd724e66e57321909e087b122357ab4506dfb4955603fc3c2ea54c9e34e9e9dcf5484aa347c89ad8c72a9fe94db26706c6850fc5442
+  data.tar.gz: a1e5ed666d7419b80da97449150ee67c95d2b1b9855e77060fff123aeaeaf268fb4caafde3242c9421d9cd042e5df14a088ecad30c837449a9fdee2b3376f6cb

data/doc/release_notes/1_8_1.md

@@ -14,7 +14,7 @@
 ## Bugfixes
 
 * `:auth` plugin: handle edge case where `:auth_header_expires_at` returns no value.
-* `:digest_auth` plugin: do not retry if there was an issue building building the authorization header after the probe.
+* `:digest_auth` plugin: do not retry if there was an issue building the authorization header after the probe.
 * `webmock` adapter: prevent mocked requests from opening a connection to the peer server that will not be used.
 * clear and cancel request timers on completion or reset, ensuring that they won't be retained way past the point where the request is gone.
 * connection: cancel and discard ping timer before closing (removes timer reference)

data/doc/release_notes/1_8_2.md

@@ -11,7 +11,7 @@ session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown opt
 
 * Use `HTTP2::Connection#closed?` internally (instead of `#state`) to check for connection state; this will, in a future release of `http-2`, seamlessly support the new `:closing` state.
 * Add missing `response` attribute reader to `HTTPX::RequestTimeoutError`.
-* Improve correctness of calling `#dup` on requests and connections.
+* Improve the correctness of calling `#dup` on requests and connections.
 
 ## Bugfixes
 
@@ -21,10 +21,10 @@ session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown opt
 * `:retries` plugin: do not retry on any HTTP/2 frame error (only on GOAWAY or PING frame errors).
 * `:persistent` plugin: do not decrement request remaining retries on ping or GOAWAY frame errors.
 * `:tracing` plugin: set connection initialization time to nil no termination (so that it doesn't get reused on persistent connections after reuse).
-* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubble up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
-* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason, making it more accurate.
+* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubbles up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
+* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason being, making it more accurate.
 * webmock adapter: `.to_timeout` helper will make the request raise a `HTTPX::RequestTimeoutError` instead of a plain `TimeoutError` (otherwise, if using persistent sessions, it'd trigger a retry instead and mess with webmock request count bookkeeping).
 * native resolver: do not transition to `:open` if the socket was closed during resolution (which happens when an error is raised while the query bytes are buffered).
 * fix for when setting a new session callback on an ssl context object which has been frozen after the first connection attempt (done by binding the ssl context callback to an internal ivar which can be changed).
 * connection: protect against `Errno::ETIMEDOUT` errors on socket close by forcing transition to closed.
-* do not set a ping timer for HTTP/1.1 on keep alive flow, as there's no ping and the connection is reestablished.
+* do not set a ping timer for HTTP/1.1 on keep-alive flow, as there's no ping and the connection is reestablished.

data/doc/release_notes/1_8_3.md

@@ -2,8 +2,6 @@
 
 ## Bugfixes
 
-options print a  warning instead of raising an error on unknown option
-
-the approach introduced in the previous version, of erroring on something people have been accidentally relying on, is too strict in hindsight for a patch version. This was reverted, and instead, a deprecation warning will be printed, to give time for folks to migrate.
-
-the format of options messages (exceptions and warnings) also slightly changes to wrap the option in quotes, for proper highlighting.
+* options print a  warning instead of raising an error on unknown option
+  * The approach introduced in the previous version, of erroring on something people have been accidentally relying on, is too strict in hindsight for a patch version. This was reverted, and instead, a deprecation warning will be printed, to give time for folks to migrate.
+* The format of option messages (exceptions and warnings) also slightly changes to wrap the option in quotes, for proper highlighting.

data/doc/release_notes/1_8_4.md

@@ -10,4 +10,4 @@
 * `:retries` plugin: resend requests which were piped to a closed connection internally.
 * `:proxy` plugin: fix issue related with reconnecting inactive connections shut down by the peer, when used with the `:persistent` plugin, where the CONNECT request wasn't being sent to establish the tunnel.
 * fixed compatibility issue starting with the `json` gem 3.0.0, when calling `HTTPX::Response#json`.
-* avoid bookkepping issue in session, where the `on_response_arrived` on a request may be called more than once (which it can happen in the `:follow_redirects` plugin, where a request may have completed due to an error, while the request is waiting to be resent due to `retry-after`).
+* avoid bookkeeping issue in session, where the `on_response_arrived` on a request may be called more than once (which it can happen in the `:follow_redirects` plugin, where a request may have completed due to an error, while the request is waiting to be resent due to `retry-after`).

data/doc/release_notes/1_9_0.md

@@ -0,0 +1,75 @@
+# 1.9.0
+
+## Features
+
+### `:hedging` plugin
+
+The `:hedging` plugin implements a strategy called "request hedging", whereby a request is sent two times, over different connections, and picking up whichever arrives first.
+
+```ruby
+http = HTTP.plugin(:hedging)
+http.get("http://www.example.com")
+# sent two times, only the fastest one comes back...
+```
+
+You can read more about it in https://gitlab.com/os85/httpx/wikis/Hedging .
+
+### `:proxy/http` plugin: new options `:proxy_headers` and `:enable_proxy_tunnel`
+
+The `:proxy/http` plugin (which gets automatically loaded by the `:proxy` plugin) gains two new options.
+
+#### `:proxy_headers`
+
+Can be passed a separate set of HTTP headers, which are going to be sent to the proxy when establishing the CONNECT proxy tunnel.
+
+```ruby
+http = HTTPX.plugin(:proxy).with(proxy_headers: { "x-proxy-1" => "foo" }, headers: { "x-header-1" => "bar" }).get("https://example.com")
+# -> CONNECT example.com HTTP/1.1
+# -> Host: example.com
+# -> X-Proxy-1: foo
+# ...
+# <- 200 OK
+# ...
+# -> GET / HTTP/1.1
+# -> X-Headers-1: bar
+# ...
+```
+
+#### `:enable_proxy_tunnel`
+
+When set to `true`, it forces the establishment of a CONNECT proxy tunnel before sending the request. Bear in mind that this will be the norm for `https://` requests, so only use this in cases where the requests are to be sent to an `http://` URL and a CONNECT proxy tunnel is required.
+
+## Improvements
+
+* `:request_timeout` will also observe the connect phase, in case a request is sent to an idle connection. This means that, if you're using `:request_timeout`, you no longer need to specify `:connect_timeout`.
+  * The same will happen if you're using `:total_request_timeout`.
+* do not require "io/wait" anymore for ruby 3.2 or higher.
+* `:proxy/http` plugin: raise a `HTTPX::ConnectTimeoutError` if there was a timeout error while waiting for the CONNECT request to complete.
+
+## Bugfixes
+
+* `:auth` plugin: fixed clause inverted check, which caused a new token to always be generated on retry.
+* `:auth` plugin: take auth_header_expires_at into account when deciding to regenerate on retry (token may have expired by the time the request will be retried).
+* `:tracing` plugin: fixed request initial time calculation in order to take into account the time to wait for a PING correctly.
+* `:tracing` plugin: fixed request initial time calculation for pending requests which were waiting for the connect phase and errored meanwhile.
+* `:proxy/http` plugin: `:headers` will not be sent anymore to the proxy when establishing the CONNECT proxy tunnel.
+* socket connect timeout bookkeeping is fixed, where in a multi request scenario, connect timeout errors shall not be raised too early if an error happens before the remainder of connections elapses.
+* `:proxy` plugin: allow proxy params to be frozen, which also fixes an issue where proxies identified as unhealthy by a previous request, would still be retried on for different hostnames.
+* `:callbacks` plugin: fix broken visibility of session `#close` method.
+* native resolver: retry dns queries on not-imp and refused errors (treats them as transient resolver errors).
+* `webmock` adapter: fix emission of `:response` callback so that this only happens after the body is fully buffered (which makes the `:callbacks` plugin `.on_response_completed` callback works the same way when and when not stubbed).
+* `:addresses`: fix support for the documented variant where a hostname/ips hash is passed.
+* `http2`: fix interests calculation, so that:
+  * a connection expects to read from connections which still have in-transit streams.
+  * an HTTP/2 with no available flow control window in its streams will wait for incoming WINDOW_UPDATE frames.
+* `http2`: pause buffering the request body if there's no available control window in the corresponding stream or connection.
+* `http2`: reset the ping timer too if a connection receives a GOAWAY frame while waiting for a PING to be ack'ed.
+* wait for read or write for any operation, considering that `OpenSSL::SSL::SSLSocket` objects may return both `.wait_readable` and `:wait_writable` for reads and writes.
+* when using `:max_requests`, also account for inflight requests when deciding to send it to the parser or the pending queue.
+* fixed `HTTPX::Options#merge` which was not freezing the resulting options object, something which happens when enabling plugins, which made resulting sessions unusable across Ractors.
+* fixed the `Alt-Svc` header parser to be able to parse values with multiple authorities.
+* fixed request params handling so that they are passed to all requests invoked (instead of only the first of them).
+
+## Chore
+
+* Emit a warning message whenever the connection is deactivated with pending requests; the message contains an internal state which should help debug it.

data/doc/release_notes/1_9_1.md

@@ -0,0 +1,32 @@
+# 1.9.1
+
+# Improvements
+
+* `:connect_timeout` will be split across the IP addresses available for the hostname. The connection phase will then loop on the list, and on each connect timeout, the next IP will tried; the connect timeout error will then only be raised if no healthy connections could be established to any of the IPs. This is the same heuristic used by curl v7.
+* Connections and parsers share the same pending requests queue: before, each had their own, and requests could fly across them depending on the several edge cases, thereby making it needlessly complex and wasteful. Also, when moving requests is necessary, they can short-circuit more efficiently.
+* Handled quoted charset property when parsing the "content-type" header in the response.
+* http1: Support peer server keep alive timeout (exposed via a response header like "Keep-Alive: timeout=10"), which overrides the client (or the default) `:keep_alive_timeout` setting.
+* http2: during the consumption loop, handle more pending requests when the window allows it.
+* several improvements on connection read/write consumption handling which save a few socket read/write syscalls.
+
+
+## Bugfixes
+
+* fix the json decoding integration with `oj`, which was using the `Oj.load` function in an unsafe manner, which `oj` documents. It now uses the `:strict` mode by default.
+* when doing Happy Eyeballs v2, do not accidentally coalesce sibling connections.
+* on session termination, ensure that idle connections are closed, something which may happen when an `alt-svc` response header creates a new connection, but no subsequent requests are sent its way.
+* fix race condition when terminating a selector, where its connections were checked on its state after termination; because terminated connections get checked back into the pool, they may be checked out before the state check happens. This fixes it by checking its current selector against itself.
+* ensure that the selector only calls the error handling once for the same connection.
+* request timeouts are now only set when the parser accepts them, and guaranteed only once.
+* when an operation timeout occurs, do not raise it on connections for which one wasn't set.
+* native resolver: fix DNS query retry handling due to a confusion about using `Enumerable.first` and `Enumerable.find`, and the former silently ignoring passed blocks.
+* native resolver: discard received answers for DNS queries which have since been dropped due to a timeout.
+* native resolver: try out the next nameserver in case the prior was unreachable.
+* http-2: keep processing unfinished streams when receiving a GOAWAY with a last stream id pointing to streams that haven't been finished.
+* `faraday` adapter: always load the `OnData` plugin, as a streaming request (which uses the `.on_data` Faraday API) may be preceded by a non-streaming request to fetch metadata (a pattern observed when using the google cloud storage ruby SDK).
+* `ntml` and `ntlmv2` plugins: when used to send multiple requests, should return an array of responses.
+* `oauth` plugin: fix wrong method call.
+* `cache` plugin: skip cache flow for error responses.
+* `proxy` plugin: make the class used for the CONNECT proxy request inherit all functionality from other loaded plugins.
+* `fiber_concurrency`: fixed some corner cases where the connection could loop indefinitely or become corrupt.
+* `tracing`: fixing request start time bookkeeping.

data/lib/httpx/adapters/faraday.rb

@@ -33,7 +33,7 @@ module Faraday
 
             @connection = @connection.plugin(:proxy).with(proxy: proxy_options)
           end
-          @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
+          @connection = @connection.plugin(OnDataPlugin)
 
           @connection = @config_block.call(@connection) || @connection if @config_block
           @connection

data/lib/httpx/adapters/webmock.rb

@@ -20,11 +20,21 @@ module WebMock
           WebMock::RequestSignature.new(
             request.verb.downcase.to_sym,
             uri.to_s,
-            body: request.body.to_s,
+            body: build_webmock_request_body(request),
             headers: request.headers.to_h
           )
         end
 
+        def build_webmock_request_body(request)
+          body = request.body
+
+          return body.to_s unless body.respond_to?(:read)
+
+          body.read.to_s.tap do
+            body.rewind
+          end
+        end
+
         def build_webmock_response(_request, response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [response.status, HTTP_REASONS[response.status]]
@@ -61,6 +71,9 @@ module WebMock
         def do_init_connection(connection, selector)
           super
 
+          # skip for connections generated by HEv2 logic.
+          return if connection.family
+
           connection.once(:unmock_connection) do
             next unless connection.current_session == self
 
@@ -133,10 +146,10 @@ module WebMock
             request.transition(:done)
             response.finish!
             request.response = response
+            response << mock_response.body.dup unless response.is_a?(HTTPX::ErrorResponse)
             request.emit_response(response)
             request_signature.headers = request.headers.to_h
 
-            response << mock_response.body.dup unless response.is_a?(HTTPX::ErrorResponse)
           elsif WebMock.net_connect_allowed?(request_signature.uri)
             if WebMock::CallbackRegistry.any_callbacks?
               request.on(:response) do |resp|

data/lib/httpx/altsvc.rb

@@ -10,7 +10,7 @@ module HTTPX
 
       H2_ALTSVC_SCHEMES = %w[https h2].freeze
 
-      ALTSVC_IGNORE_IVARS = %i[@ssl].freeze
+      ALTSVC_IGNORE_IVARS = %i[ssl].freeze
 
       def send(request)
         request.headers["alt-used"] = @origin.authority if @parser && !@write_buffer.full? && match_altsvcs?(request.uri)
@@ -30,7 +30,7 @@ module HTTPX
       # +uri+
       def match_altsvcs?(uri)
         @origins.any? { |origin| altsvc_match?(uri, origin) } ||
-          AltSvc.cached_altsvc(@origin).any? do |altsvc|
+          AltSvc.cached_altsvc(@origin.to_s).any? do |altsvc|
             origin = altsvc["origin"]
             altsvc_match?(origin, uri.origin)
           end
@@ -115,33 +115,45 @@ module HTTPX
         return
       end
 
-      parse(altsvc) do |alt_origin, alt_params|
+      parse(altsvc, host: host) do |alt_origin, alt_params|
         alt_origin.host ||= host
         yield(alt_origin, origin, alt_params)
       end
     end
 
-    def parse(altsvc)
-      return enum_for(__method__, altsvc) unless block_given?
+    def parse(altsvc, host: nil)
+      return enum_for(__method__, altsvc, host: host) unless block_given?
 
       scanner = StringScanner.new(altsvc)
       until scanner.eos?
-        alt_service = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
+        alt_services = [] #: Array[String]
 
-        alt_params = []
+        while (alt_service = scanner.scan(/[^=]+=("[^"]+")/))
+          alt_services << alt_service
+          scanner.skip(/[, ]+/)
+        end
+
+        scanner.skip(/;/)
+
+        alt_params = [] #: Array[String]
         loop do
           alt_param = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
           alt_params << alt_param.strip if alt_param
           scanner.skip(/;/)
           break if scanner.eos? || scanner.scan(/ *, */)
         end
-        alt_params = Hash[alt_params.map { |field| field.split("=", 2) }]
+        alt_params = Hash[alt_params.map do |field|
+          field.split("=", 2)
+        end]
 
-        alt_proto, alt_authority = alt_service.split("=", 2)
-        alt_origin = parse_altsvc_origin(alt_proto, alt_authority)
-        return unless alt_origin
+        alt_services.each do |alt_service|
+          alt_proto, alt_authority = alt_service.split("=", 2)
+          alt_origin = parse_altsvc_origin(alt_proto, alt_authority, host: host)
 
-        yield(alt_origin, alt_params.merge("proto" => alt_proto))
+          next unless alt_origin
+
+          yield(alt_origin, alt_params.merge("proto" => alt_proto))
+        end
       end
     end
 
@@ -149,19 +161,21 @@ module HTTPX
       case alt_proto
       when "h2c"
         "http"
-      when "h2"
+      when "h2", "quic", /^h3/
         "https"
       end
     end
 
-    def parse_altsvc_origin(alt_proto, alt_origin)
+    def parse_altsvc_origin(alt_proto, alt_origin, host: nil)
       alt_scheme = parse_altsvc_scheme(alt_proto)
 
       return unless alt_scheme
 
       alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
 
-      URI.parse("#{alt_scheme}://#{alt_origin}")
+      uri = URI.parse("#{alt_scheme}://#{alt_origin}")
+      uri.host = host if uri.host.nil? || uri.host.empty?
+      uri
     end
   end
 end

data/lib/httpx/chainable.rb

@@ -5,9 +5,11 @@ module HTTPX
   # delegates to a default session when extended.
   module Chainable
     %w[head get post put delete trace options connect patch].each do |meth|
+      http_verb = meth.upcase
       class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+        # sends a #{http_verb} request for the given +uri+, using +options+ for each.
         def #{meth}(*uri, **options)                # def get(*uri, **options)
-          request("#{meth.upcase}", uri, **options) #   request("GET", uri, **options)
+          request("#{http_verb}", uri, **options)   #   request("GET", uri, **options)
         end                                         # end
       MOD
     end
@@ -17,6 +19,7 @@ module HTTPX
       branch(default_options).request(...)
     end
 
+    # returns a new session with the "Accept" header set to +type+.
     def accept(type)
       with(headers: { "accept" => String(type) })
     end

data/lib/httpx/connection/http1.rb

@@ -20,21 +20,21 @@ module HTTPX
 
     attr_accessor :max_concurrent_requests
 
-    def initialize(buffer, options)
+    def initialize(buffer, pending, options)
       @options = options
       @max_concurrent_requests = @options.max_concurrent_requests || MAX_REQUESTS
       @max_requests = @options.max_requests
       @parser = Parser::HTTP1.new(self, options.max_response_headers, options.max_response_header_value_size)
       @buffer = buffer
       @version = [1, 1]
-      @pending = []
+      @pending = pending
       @requests = []
       @callbacks = @request = nil
       @handshake_completed = @pipelining = false
     end
 
     def timeout
-      @options.timeout[:operation_timeout]
+      @options.timeout.operation_timeout
     end
 
     def interests
@@ -48,28 +48,31 @@ module HTTPX
     end
 
     def reset
-      if @ping_timer
-        @ping_timer.cancel
-        @ping_timer = nil
-      end
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
-      reset_requests
     end
 
+    # move incompleted requests back to pending queue.
     def reset_requests
-      @requests.reverse_each do |request|
-        next if request.response
+      completed_idx = 0
+      @requests.each_with_index do |request, idx|
+        if request.response
+          completed_idx = idx + 1
+          next
+        end
 
         request.transition(:idle)
-        @pending.unshift(request)
       end
+      # drop completed requests
+      @requests.shift(completed_idx)
+      @pending.unshift(*@requests)
       @requests.clear
     end
 
     def close
       reset
+      reset_requests
       emit(:close)
     end
 
@@ -92,16 +95,16 @@ module HTTPX
       @parser << data
     end
 
-    def send(request)
-      unless @max_requests.positive?
-        @pending << request
-        return
+    def send(request, head = false) # rubocop:disable Naming/PredicateMethod
+      unless @max_requests.positive? && @max_requests > @requests.size
+        head ? @pending.unshift(request) : @pending << request
+        return false
       end
 
-      return if @requests.include?(request)
-
       @requests << request
       @pipelining = @max_concurrent_requests > 1 && @requests.size > 1
+      emit(:request_accepted, request)
+      true
     end
 
     def consume
@@ -132,9 +135,9 @@ module HTTPX
       headers = request.options.headers_class.new(h)
       response = request.options.response_class.new(request,
                                                     @parser.status_code,
-                                                    @parser.http_version.join("."),
+                                                    @parser.http_version,
                                                     headers)
-      request.log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version.join(".")}" }
+      request.log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version}" }
       request.log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{log_redact_headers(v)}" }.join("\n") }
 
       if response.content_length && response.content_length > request.options.max_response_body_size
@@ -187,7 +190,7 @@ module HTTPX
 
       @request = nil
       @requests.shift
-      response = request.response
+      response = request.response #: Response
       emit(:response, request, response)
 
       if @parser.upgrade?
@@ -198,19 +201,16 @@ module HTTPX
 
       @parser.reset!
       @max_requests -= 1
-      if response.is_a?(ErrorResponse)
-        disable
-      else
-        manage_connection(request, response)
-      end
+      manage_connection(request, response)
 
       if exhausted?
-        @pending.unshift(*@requests)
-        @requests.clear
+        reset_requests
 
         emit(:exhausted)
+      elsif @requests.any?
+        consume
       else
-        send(@pending.shift) unless @pending.empty?
+        send(@pending.shift, true) unless @pending.empty?
       end
     end
 
@@ -245,13 +245,16 @@ module HTTPX
     def ping
       reset
       emit(:reset)
-      emit(:exhausted)
     end
 
     def waiting_for_ping?
       false
     end
 
+    def no_more_requests?
+      @requests.empty?
+    end
+
     private
 
     def manage_connection(request, response)
@@ -260,8 +263,7 @@ module HTTPX
       when /keep-alive/i
         if @handshake_completed
           if @max_requests.zero?
-            @pending.unshift(*@requests)
-            @requests.clear
+            reset_requests
             emit(:exhausted)
           end
           return
@@ -275,10 +277,7 @@ module HTTPX
         end]
         @max_requests = parameters["max"].to_i - 1 if parameters.key?("max")
 
-        if parameters.key?("timeout")
-          keep_alive_timeout = parameters["timeout"].to_i
-          emit(:timeout, keep_alive_timeout)
-        end
+        emit(:keep_alive_timeout, parameters["timeout"].to_i) if parameters.key?("timeout")
         @handshake_completed = true
       when /close/i
         disable