httpx 0.18.0 → 0.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 372f89cdf05727a32d23467503299ae77831cb5d23356467dc0c7f3a22bbfd0c
-  data.tar.gz: bbb3df9079bf4f5a449f37f34dd6b1d3208a978e8a8eaa7fdd69ea9d1829ac6c
+  metadata.gz: 431fcabfda42f5d6010d903a15c6a83357123c9eef3528a769755c8639f1ec61
+  data.tar.gz: 52512337b7b2081a4ab123f7261dee14adb97da019fc9244b9ddf8e7de53c904
 SHA512:
-  metadata.gz: 38211af1e56fbc823ad0780198579ff11d4fa4b5b64677af95e78361f8b274d0dc43b124697358f1a0b17c2d45e4cdd620f97ca983af7fa60ce59515e9b51785
-  data.tar.gz: 2c9d48f3ad7a499046ab94ac3ee1831f1623ce44990de0f08320ac6e5ce3767ca938381cd7b96c3799477f201a811aa5c446d62f88bd58c6e1e0afd84c53af75
+  metadata.gz: 7777af904a2e5a8f6f34984a69cb022c853483b6634dd631a3fbe92c9005fadb3637a21a214ff1e14ef4729ffa70d68362b703b9ccd25e2904b820fc674dbe6b
+  data.tar.gz: 94d92ad004319ecb3098b5e901921bfaf5d818cbb0e2e87eed8987248d1cc52d0fc70a5dc1dfe1a92faa8eae9e7074c926c0c01563002cb8067af449ae79fd51

data/README.md

@@ -45,7 +45,7 @@ response = HTTPX.get("https://nghttp2.org")
 puts response.status #=> 200
 body = response.body
 puts body #=> #<HTTPX::Response ...
-``` 
+```
 
 You can also send as many requests as you want simultaneously:
 
@@ -79,7 +79,7 @@ In Ruby, HTTP client implementations are a known cheap commodity. Why this one?
 
 ### Concurrency
 
-This library supports HTTP/2 seamlessly (which means, if the request is secure, and the server support ALPN negotiation AND HTTP/2, the request will be made through HTTP/2). If you pass multiple URIs, and they can utilize the same connection, they will run concurrently in it. 
+This library supports HTTP/2 seamlessly (which means, if the request is secure, and the server support ALPN negotiation AND HTTP/2, the request will be made through HTTP/2). If you pass multiple URIs, and they can utilize the same connection, they will run concurrently in it.
 
 However if the server supports HTTP/1.1, it will try to use HTTP pipelining, falling back to 1 request at a time if the server doesn't support it (if the server support Keep-Alive connections, it will reuse the same connection).
 
@@ -137,13 +137,18 @@ In order to use HTTP/2 under JRuby, [check this link](https://gitlab.com/honeyry
 
 ### Known bugs
 
-Doesn't work with ruby 2.4.0 for Windows (see [#36](https://gitlab.com/honeyryderchuck/httpx/issues/36)).
+* Doesn't work with ruby 2.4.0 for Windows (see [#36](https://gitlab.com/honeyryderchuck/httpx/issues/36)).
+* Using `total_timeout` along with the `:persistent` plugin [does not work as you might expect](https://gitlab.com/honeyryderchuck/httpx/-/wikis/Timeouts#total_timeout).
+
+## Versioning Policy
+
+Although 0.x software, `httpx` is considered API-stable and production-ready, i.e. current API or options may be subject to deprecation and emit log warnings, but can only effectively be removed in a major version change.
 
 ## Contributing
 
 * Discuss your contribution in an issue
 * Fork it
 * Make your changes, add some tests
-* Ensure all tests pass (`bundle exec rake test`)
+* Ensure all tests pass (`docker-compose -f docker-compose.yml -f docker-compose-ruby-{RUBY_VERSION}.yml run httpx bundle exec rake test`)
 * Open a Merge Request (that's Pull Request in Github-ish)
 * Wait for feedback

data/doc/release_notes/0_18_1.md

@@ -0,0 +1,12 @@
+# 0.18.1
+
+## Bugfixes
+
+* HTTP/1.1 pipelining logs were logging the previously-buffered requests all together for each triggered request, which created some confusion for users when reporting errors. This has been fixed.
+* HTTP/2 coalescing is now skipped when performing TLS connections with VERIFY_NONE.
+* HTTP/2 peer GOAWAY frames will now result in a (retryable) connection error, instead of being ignored and leaving a "ghost" connection behind.
+* fixed total timeout call which was not raising the exception.
+
+## Chore
+
+This gem now requires MFA-based gem releases.

data/doc/release_notes/0_18_2.md

@@ -0,0 +1,10 @@
+# 0.18.2
+
+## Bugfixes
+
+* A bug was reported and fixed, whereby a persistent connection with a `:total_timeout` set was triggering the timeout and leaving the process looping indefinitely.
+
+
+## Chore
+
+The quirk of using the `:persistent` plugin with `:total_timeout` has been documented: https://gitlab.com/honeyryderchuck/httpx/-/wikis/Timeouts#total_timeout.

data/doc/release_notes/0_18_3.md

@@ -0,0 +1,7 @@
+# 0.18.3
+
+## Bugfixes
+
+* request bodies eager-loaded from enumerables yield duped partial chunks.
+
+An error was observed while looking at webmock integration, where requests formed via the multipart plugin were returning an empty string as body. The issue was caused by an optimization on multipart encoder, which reuses the same buffer when reading chunks. Unfortunately, these cannot be yielded the same way via IO.copy_stream, as the same (cleared) buffer will be used to generate the eager-loaded body chunks.

data/doc/release_notes/0_18_4.md

@@ -0,0 +1,14 @@
+# 0.18.4
+
+## Improvements
+
+* faraday adapter: added support for `#on_data` callback in order to support [faraday streaming](https://lostisland.github.io/faraday/usage/streaming).
+
+* multipart plugin: removed support for file mime type detection using `mime-types`. The reasoning behind it was that `mime-types` uses the filename, which is a very inaccurate detection strategy (ex: an mp4 video will be identified as `application/mp4`, instead of the correct `video/mp4`).
+* multipart plugin: supported for file mime type detection using `marcel` and `filemagic` was added. Both use the magic header bytes, which is a more accurate strategy for file type detection.
+
+## Bugfixes
+
+* webmock adapter has been reimplemented to work with `httpx` plugins (such as the `:retries` plugin). Some other fixes were applied to make it work better under `vcr` (a common `webmock` extension).
+
+* fixed the URI-related bug which was making requests stall under ruby 3.1 (still not officially testing against it).

data/doc/release_notes/0_18_5.md

@@ -0,0 +1,10 @@
+# 0.18.5
+
+## Improvements
+
+* ruby 3.1 is now officially supported.
+* when a user sets a `Host` header for an HTTP/2 request, this will be used in the `:authority` HTTP/2 pseudo-header, instead of silently ignored (mimicking what "curl" does).
+
+## Bugfixes
+
+* fixed "throw outside of catch block" error happening when pipelining requests on an HTTP/1 connection and resulting in a timeout.

data/doc/release_notes/0_18_6.md

@@ -0,0 +1,5 @@
+# 0.18.6
+
+## Bugfixes
+
+* multipart plugin: fixed missing constant in `filemagic` integration.

data/doc/release_notes/0_18_7.md

@@ -0,0 +1,5 @@
+# 0.18.6
+
+## Bugfixes
+
+* multipart plugin: fixed `filemagic` integration by rewinding the file after mime-type detection.

data/doc/release_notes/0_19_0.md

@@ -0,0 +1,39 @@
+# 0.19.0
+
+## Features
+
+### Happy Eyeballs v2
+
+When the system supports dual-stack networking, `httpx` implements the Happy Eyeballs v2 algorithm (RFC 8305) to resolve hostnames to both IPv6 and IPv4 addresses while privileging IPv6 connectivity. This is implemented by `httpx` both for the `:native` as well as the `:https` (DoH) resolver (which do not perform address sorting, thereby being "DNS-based load-balancing" friendly), and "outsourced" to `getaddrinfo` when using the `:system` resolver.
+
+IPv6 connectivity will also be privileged for `/etc/hosts` local DNS (i.e. `localhost` connections will connec to `::1`).
+
+A new option, `:ip_families`, will also be available (`[Socket::AF_INET6, Socket::AF_INET]` in dual-stack systems). If you'd like to i.e. force IPv4 connectivity, you can do use it (`client = HTTPX.with(ip_families: [Socket::AF_INET])`).
+
+## Improvements
+
+### DNS: :system resolver uses getaddrinfo (instead of the resolver lib)
+
+The `:system` resolver switched to using the `getaddinfo` system function to perform DNS requests. Not only is this call **not** blocking the session event loop anymore (unlike pre-0.19.0 `:system` resolver), it adds a lot of functionality that the stdlib `resolv` library just doesn't support at the moment (such as SRV records).
+
+### HTTP/2 proxy support
+
+The `:proxy` plugin handles "prior-knowledge" HTTP/2 proxies.
+
+```ruby
+HTTPX.plugin(:proxy, fallback_protocol: "h2").with_proxy(uri: "http://http2-proxy:3128").get(...
+```
+
+Connection coalescing has also been enabled for proxied connections (also `CONNECT`-tunneled connections).
+
+### curl-to-httpx
+
+widget in [project website](https://honeyryderchuck.gitlab.io/httpx/) to turn curl commands into the equivalent `httpx` code.
+
+## Bugfixes
+
+* faraday adapter now supports passing session options.
+* proxy: several fixes which enabled env-var (`HTTP(S)_PROXY`) defined proxy support.
+* proxy: fixed graceful recovery from proxy tcp connect errors.
+* several fixes around CNAMEs timeouts with the native resolver.
+* https resolver is now closed when wrapping session closes (it was left open).

data/doc/release_notes/0_19_1.md

@@ -0,0 +1,5 @@
+# 0.19.1
+
+## Bugfixes
+
+Fixing a DNS dual-stack case where one the resolvers may have finished way before the previous one and will therefore return no timeout.

data/doc/release_notes/0_19_2.md

@@ -0,0 +1,7 @@
+# 0.19.2
+
+## Bugfixes
+
+* skip resolution delay path for early resolve cases
+
+when the early resolve path (using IP, /etc/hosts IP, IP from cache) is followed, emit_addresses is called, and in a particular case (dual-stack network but using an IPv4 address), the happy eyeballs resolution delay path was activated when it shouldn't (it's meant to be used only for DNS network requests), and resulted in @pool being called before it was ever set. This simple check ensures that it doesn't happen before it must.

data/doc/release_notes/0_19_3.md

@@ -0,0 +1,6 @@
+# 0.19.3
+
+## Bugfixes
+
+* `retries` plugin: allow passing floats to `:retry_after` option.
+* dns: fixing cache lookups filtering by IP family which was causing socket connect handshake to start with no IP.

data/lib/httpx/adapters/faraday.rb

@@ -21,6 +21,17 @@ module Faraday
       end
       # :nocov:
 
+      unless Faraday::RequestOptions.method_defined?(:stream_response?)
+        module RequestOptionsExtensions
+          refine Faraday::RequestOptions do
+            def stream_response?
+              false
+            end
+          end
+        end
+        using RequestOptionsExtensions
+      end
+
       module RequestMixin
         using ::HTTPX::HashExtensions
 
@@ -64,6 +75,30 @@ module Faraday
 
       include RequestMixin
 
+      module OnDataPlugin
+        module RequestMethods
+          attr_writer :response_on_data
+
+          def response=(response)
+            super
+
+            return if response.is_a?(::HTTPX::ErrorResponse)
+
+            response.body.on_data = @response_on_data
+          end
+        end
+
+        module ResponseBodyMethods
+          attr_writer :on_data
+
+          def write(chunk)
+            return super unless @on_data
+
+            @on_data.call(chunk, chunk.bytesize)
+          end
+        end
+      end
+
       class Session < ::HTTPX::Session
         plugin(:compression)
         plugin(:persistent)
@@ -104,7 +139,7 @@ module Faraday
 
           def on_response(&blk)
             if blk
-              @on_response = lambda do |response|
+              @on_response = ->(response) do
                 blk.call(response)
               end
               self
@@ -137,15 +172,21 @@ module Faraday
         end
 
         def run
-          requests = @handlers.map { |handler| build_request(handler.env) }
           env = @handlers.last.env
 
-          proxy_options = { uri: env.request.proxy }
-
           session = @session.with(options_from_env(env))
-          session = session.plugin(:proxy).with(proxy: proxy_options) if env.request.proxy
+          session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
+          session = session.plugin(OnDataPlugin) if env.request.stream_response?
+
+          requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
 
-          responses = session.request(requests)
+          if env.request.stream_response?
+            requests.each do |request|
+              request.response_on_data = env.request.on_data
+            end
+          end
+
+          responses = session.request(*requests)
           Array(responses).each_with_index do |response, index|
             handler = @handlers[index]
             handler.on_response.call(response)
@@ -162,9 +203,9 @@ module Faraday
         end
       end
 
-      def initialize(app)
+      def initialize(app, options = {})
         super(app)
-        @session = Session.new
+        @session = Session.new(options)
       end
 
       def call(env)
@@ -172,6 +213,7 @@ module Faraday
         if parallel?(env)
           handler = env[:parallel_manager].enqueue(env)
           handler.on_response do |response|
+            response.raise_for_status
             save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
               response_headers.merge!(response.headers)
             end
@@ -179,11 +221,15 @@ module Faraday
           return handler
         end
 
-        meth, uri, request_options = build_request(env)
-
         session = @session.with(options_from_env(env))
-        session = session.plugin(:proxy).with(proxy: proxy_options) if env.request.proxy
-        response = session.__send__(meth, uri, **request_options)
+        session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
+        session = session.plugin(OnDataPlugin) if env.request.stream_response?
+
+        request = session.build_request(*build_request(env))
+
+        request.response_on_data = env.request.on_data if env.request.stream_response?
+
+        response = session.request(request)
         response.raise_for_status unless response.is_a?(::HTTPX::Response)
         save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
           response_headers.merge!(response.headers)

data/lib/httpx/adapters/webmock.rb

@@ -16,56 +16,8 @@ module WebMock
     # Requests are "hijacked" at the session, before they're distributed to a connection.
     #
     module Plugin
-      module InstanceMethods
-        private
-
-        def send_requests(*requests)
-          request_signatures = requests.map do |request|
-            request_signature = _build_webmock_request_signature(request)
-            WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
-            request_signature
-          end
-
-          responses = request_signatures.map do |request_signature|
-            WebMock::StubRegistry.instance.response_for_request(request_signature)
-          end
-
-          real_requests = {}
-
-          requests.each_with_index.each_with_object([request_signatures, responses]) do |(request, idx), (sig_reqs, mock_responses)|
-            if (webmock_response = mock_responses[idx])
-              mock_responses[idx] = _build_from_webmock_response(request, webmock_response)
-              WebMock::CallbackRegistry.invoke_callbacks({ lib: :httpx }, sig_reqs[idx], webmock_response)
-              log { "mocking #{request.uri} with #{mock_responses[idx].inspect}" }
-            elsif WebMock.net_connect_allowed?(sig_reqs[idx].uri)
-              log { "performing #{request.uri}" }
-              real_requests[request] = idx
-            else
-              raise WebMock::NetConnectNotAllowedError, sig_reqs[idx]
-            end
-          end
-
-          unless real_requests.empty?
-            reqs = real_requests.keys
-            reqs.zip(super(*reqs)).each do |req, res|
-              idx = real_requests[req]
-
-              if WebMock::CallbackRegistry.any_callbacks?
-                webmock_response = _build_webmock_response(req, res)
-                WebMock::CallbackRegistry.invoke_callbacks(
-                  { lib: :httpx, real_request: true }, request_signatures[idx],
-                  webmock_response
-                )
-              end
-
-              responses[idx] = res
-            end
-          end
-
-          responses
-        end
-
-        def _build_webmock_request_signature(request)
+      class << self
+        def build_webmock_request_signature(request)
           uri = WebMock::Util::URI.heuristic_parse(request.uri)
           uri.path = uri.normalized_path.gsub("[^:]//", "/")
 
@@ -77,7 +29,7 @@ module WebMock
           )
         end
 
-        def _build_webmock_response(_request, response)
+        def build_webmock_response(_request, response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [response.status, HTTP_REASONS[response.status]]
           webmock_response.body = response.body.to_s
@@ -85,10 +37,10 @@ module WebMock
           webmock_response
         end
 
-        def _build_from_webmock_response(request, webmock_response)
-          return _build_error_response(request, HTTPX::TimeoutError.new(1, "Timed out")) if webmock_response.should_timeout
+        def build_from_webmock_response(request, webmock_response)
+          return build_error_response(request, HTTPX::TimeoutError.new(1, "Timed out")) if webmock_response.should_timeout
 
-          return _build_error_response(request, webmock_response.exception) if webmock_response.exception
+          return build_error_response(request, webmock_response.exception) if webmock_response.exception
 
           response = request.options.response_class.new(request,
                                                         webmock_response.status[0],
@@ -98,10 +50,70 @@ module WebMock
           response
         end
 
-        def _build_error_response(request, exception)
+        def build_error_response(request, exception)
           HTTPX::ErrorResponse.new(request, exception, request.options)
         end
       end
+
+      module InstanceMethods
+        def build_connection(*)
+          connection = super
+          connection.once(:unmock_connection) do
+            pool.__send__(:resolve_connection, connection)
+            pool.__send__(:unregister_connection, connection) unless connection.addresses
+          end
+          connection
+        end
+      end
+
+      module ConnectionMethods
+        def initialize(*)
+          super
+          @mocked = true
+        end
+
+        def open?
+          return true if @mocked
+
+          super
+        end
+
+        def interests
+          return if @mocked
+
+          super
+        end
+
+        def send(request)
+          request_signature = Plugin.build_webmock_request_signature(request)
+          WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+          if (mock_response = WebMock::StubRegistry.instance.response_for_request(request_signature))
+            response = Plugin.build_from_webmock_response(request, mock_response)
+            WebMock::CallbackRegistry.invoke_callbacks({ lib: :httpx }, request_signature, mock_response)
+            log { "mocking #{request.uri} with #{mock_response.inspect}" }
+            request.response = response
+            request.emit(:response, response)
+          elsif WebMock.net_connect_allowed?(request_signature.uri)
+            if WebMock::CallbackRegistry.any_callbacks?
+              request.on(:response) do |resp|
+                unless resp.is_a?(HTTPX::ErrorResponse)
+                  webmock_response = Plugin.build_webmock_response(request, resp)
+                  WebMock::CallbackRegistry.invoke_callbacks(
+                    { lib: :httpx, real_request: true }, request_signature,
+                    webmock_response
+                  )
+                end
+              end
+            end
+            @mocked = false
+            emit(:unmock_connection, self)
+            super
+          else
+            raise WebMock::NetConnectNotAllowedError, request_signature
+          end
+        end
+      end
     end
 
     class HttpxAdapter < HttpLibAdapter
@@ -109,12 +121,12 @@ module WebMock
 
       class << self
         def enable!
-          @original_session = ::HTTPX::Session
+          @original_session = HTTPX::Session
 
-          webmock_session = ::HTTPX.plugin(Plugin)
+          webmock_session = HTTPX.plugin(Plugin)
 
-          ::HTTPX.send(:remove_const, :Session)
-          ::HTTPX.send(:const_set, :Session, webmock_session.class)
+          HTTPX.send(:remove_const, :Session)
+          HTTPX.send(:const_set, :Session, webmock_session.class)
         end
 
         def disable!

data/lib/httpx/altsvc.rb

@@ -70,7 +70,7 @@ module HTTPX
 
       scanner = StringScanner.new(altsvc)
       until scanner.eos?
-        alt_origin = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
+        alt_service = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
 
         alt_params = []
         loop do
@@ -80,29 +80,45 @@ module HTTPX
           break if scanner.eos? || scanner.scan(/ *, */)
         end
         alt_params = Hash[alt_params.map { |field| field.split("=") }]
-        yield(parse_altsvc_origin(alt_origin), alt_params)
+
+        alt_proto, alt_authority = alt_service.split("=")
+        alt_origin = parse_altsvc_origin(alt_proto, alt_authority)
+        return unless alt_origin
+
+        yield(alt_origin, alt_params.merge("proto" => alt_proto))
+      end
+    end
+
+    def parse_altsvc_scheme(alt_proto)
+      case alt_proto
+      when "h2c"
+        "http"
+      when "h2"
+        "https"
       end
     end
 
     # :nocov:
     if RUBY_VERSION < "2.2"
-      def parse_altsvc_origin(alt_origin)
-        alt_proto, alt_origin = alt_origin.split("=")
+      def parse_altsvc_origin(alt_proto, alt_origin)
+        alt_scheme = parse_altsvc_scheme(alt_proto) or return
+
         alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
         if alt_origin.start_with?(":")
-          alt_origin = "#{alt_proto}://dummy#{alt_origin}"
+          alt_origin = "#{alt_scheme}://dummy#{alt_origin}"
           uri = URI.parse(alt_origin)
           uri.host = nil
           uri
         else
-          URI.parse("#{alt_proto}://#{alt_origin}")
+          URI.parse("#{alt_scheme}://#{alt_origin}")
         end
       end
     else
-      def parse_altsvc_origin(alt_origin)
-        alt_proto, alt_origin = alt_origin.split("=")
+      def parse_altsvc_origin(alt_proto, alt_origin)
+        alt_scheme = parse_altsvc_scheme(alt_proto) or return
         alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
-        URI.parse("#{alt_proto}://#{alt_origin}")
+
+        URI.parse("#{alt_scheme}://#{alt_origin}")
       end
     end
     # :nocov:

data/lib/httpx/connection/http1.rb

@@ -36,6 +36,8 @@ module HTTPX
 
       request = @requests.first
 
+      return unless request
+
       return :w if request.interests == :w || !@buffer.empty?
 
       :r
@@ -182,7 +184,7 @@ module HTTPX
       end
 
       if @pipelining
-        disable
+        catch(:called) { disable }
       else
         @requests.each do |request|
           emit(:error, request, ex)
@@ -295,10 +297,6 @@ module HTTPX
       extra_headers
     end
 
-    def headline_uri(request)
-      request.path
-    end
-
     def handle(request)
       catch(:buffer_full) do
         request.transition(:headers)
@@ -312,9 +310,14 @@ module HTTPX
       end
     end
 
+    def join_headline(request)
+      "#{request.verb.to_s.upcase} #{request.path} HTTP/#{@version.join(".")}"
+    end
+
     def join_headers(request)
-      @buffer << "#{request.verb.to_s.upcase} #{headline_uri(request)} HTTP/#{@version.join(".")}" << CRLF
-      log(color: :yellow) { "<- HEADLINE: #{@buffer.to_s.chomp.inspect}" }
+      headline = join_headline(request)
+      @buffer << headline << CRLF
+      log(color: :yellow) { "<- HEADLINE: #{headline.chomp.inspect}" }
       extra_headers = set_protocol_headers(request)
       join_headers2(request.headers.each(extra_headers))
       log { "<- " }

data/lib/httpx/connection/http2.rb

@@ -16,6 +16,12 @@ module HTTPX
       end
     end
 
+    class GoawayError < Error
+      def initialize
+        super(0, :no_error)
+      end
+    end
+
     attr_reader :streams, :pending
 
     def initialize(buffer, options)
@@ -152,10 +158,6 @@ module HTTPX
       end
     end
 
-    def headline_uri(request)
-      request.path
-    end
-
     def handle(request, stream)
       catch(:buffer_full) do
         request.transition(:headers)
@@ -207,13 +209,19 @@ module HTTPX
       {
         ":scheme" => request.scheme,
         ":method" => request.verb.to_s.upcase,
-        ":path" => headline_uri(request),
+        ":path" => request.path,
         ":authority" => request.authority,
       }
     end
 
     def join_headers(stream, request)
       extra_headers = set_protocol_headers(request)
+
+      if request.headers.key?("host")
+        log { "forbidden \"host\" header found (#{request.headers["host"]}), will use it as authority..." }
+        extra_headers[":authority"] = request.headers["host"]
+      end
+
       log(level: 1, color: :yellow) do
         request.headers.merge(extra_headers).each.map { |k, v| "#{stream.id}: -> HEADER: #{k}: #{v}" }.join("\n")
       end
@@ -302,7 +310,7 @@ module HTTPX
       @drains.delete(request)
       @streams.delete(request)
 
-      if error && error != :no_error
+      if error
         ex = Error.new(stream.id, error)
         ex.set_backtrace(caller)
         response = ErrorResponse.new(request, ex, request.options)
@@ -344,9 +352,16 @@ module HTTPX
 
     def on_close(_last_frame, error, _payload)
       is_connection_closed = @connection.state == :closed
-      if error && error != :no_error
+      if error
         @buffer.clear if is_connection_closed
-        ex = Error.new(0, error)
+        if error == :no_error
+          ex = GoawayError.new
+          @pending.unshift(*@streams.keys)
+          @drains.clear
+          @streams.clear
+        else
+          ex = Error.new(0, error)
+        end
         ex.set_backtrace(caller)
         handle_error(ex)
       end