httpx-patched 1.6.2.1

data/lib/httpx/plugins/stream_bidi.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for bidirectional HTTP/2 streams.
+    #
+    # https://gitlab.com/os85/httpx/wikis/StreamBidi
+    #
+    # It is required that the request body allows chunk to be buffered, (i.e., responds to +#<<(chunk)+).
+    module StreamBidi
+      # Extension of the Connection::HTTP2 class, which adds functionality to
+      # deal with a request that can't be drained and must be interleaved with
+      # the response streams.
+      #
+      # The streams keeps send DATA frames while there's data; when they're ain't,
+      # the stream is kept open; it must be explicitly closed by the end user.
+      #
+      class HTTP2Bidi < Connection::HTTP2
+        def initialize(*)
+          super
+          @lock = Thread::Mutex.new
+        end
+
+        %i[close empty? exhausted? send <<].each do |lock_meth|
+          class_eval(<<-METH, __FILE__, __LINE__ + 1)
+            # lock.aware version of +#{lock_meth}+
+            def #{lock_meth}(*)                # def close(*)
+              return super if @lock.owned?
+
+              # small race condition between
+              # checking for ownership and
+              # acquiring lock.
+              # TODO: fix this at the parser.
+              @lock.synchronize { super }
+            end
+          METH
+        end
+
+        private
+
+        %i[join_headers join_trailers join_body].each do |lock_meth|
+          class_eval(<<-METH, __FILE__, __LINE__ + 1)
+            # lock.aware version of +#{lock_meth}+
+            private def #{lock_meth}(*)                # private def join_headers(*)
+              return super if @lock.owned?
+
+              # small race condition between
+              # checking for ownership and
+              # acquiring lock.
+              # TODO: fix this at the parser.
+              @lock.synchronize { super }
+            end
+          METH
+        end
+
+        def handle_stream(stream, request)
+          request.on(:body) do
+            next unless request.headers_sent
+
+            handle(request, stream)
+
+            emit(:flush_buffer)
+          end
+          super
+        end
+
+        # when there ain't more chunks, it makes the buffer as full.
+        def send_chunk(request, stream, chunk, next_chunk)
+          super
+
+          return if next_chunk
+
+          request.transition(:waiting_for_chunk)
+          throw(:buffer_full)
+        end
+
+        # sets end-stream flag when the request is closed.
+        def end_stream?(request, next_chunk)
+          request.closed? && next_chunk.nil?
+        end
+      end
+
+      # BidiBuffer is a Buffer which can be receive data from threads othr
+      # than the thread of the corresponding Connection/Session.
+      #
+      # It synchronizes access to a secondary internal +@oob_buffer+, which periodically
+      # is reconciled to the main internal +@buffer+.
+      class BidiBuffer < Buffer
+        def initialize(*)
+          super
+          @parent_thread = Thread.current
+          @oob_mutex = Thread::Mutex.new
+          @oob_buffer = "".b
+        end
+
+        # buffers the +chunk+ to be sent
+        def <<(chunk)
+          return super if Thread.current == @parent_thread
+
+          @oob_mutex.synchronize { @oob_buffer << chunk }
+        end
+
+        # reconciles the main and secondary buffer (which receives data from other threads).
+        def rebuffer
+          raise Error, "can only rebuffer while waiting on a response" unless Thread.current == @parent_thread
+
+          @oob_mutex.synchronize do
+            @buffer << @oob_buffer
+            @oob_buffer.clear
+          end
+        end
+      end
+
+      # Proxy to wake up the session main loop when one
+      # of the connections has buffered data to write. It abides by the HTTPX::_Selectable API,
+      # which allows it to be registered in the selector alongside actual HTTP-based
+      # HTTPX::Connection objects.
+      class Signal
+        def initialize
+          @closed = false
+          @pipe_read, @pipe_write = IO.pipe
+        end
+
+        def state
+          @closed ? :closed : :open
+        end
+
+        # noop
+        def log(**, &_); end
+
+        def to_io
+          @pipe_read.to_io
+        end
+
+        def wakeup
+          return if @closed
+
+          @pipe_write.write("\0")
+        end
+
+        def call
+          return if @closed
+
+          @pipe_read.readpartial(1)
+        end
+
+        def interests
+          return if @closed
+
+          :r
+        end
+
+        def timeout; end
+
+        def terminate
+          @pipe_write.close
+          @pipe_read.close
+          @closed = true
+        end
+
+        # noop (the owner connection will take of it)
+        def handle_socket_timeout(interval); end
+      end
+
+      class << self
+        def load_dependencies(klass)
+          klass.plugin(:stream)
+        end
+
+        def extra_options(options)
+          options.merge(fallback_protocol: "h2")
+        end
+      end
+
+      module InstanceMethods
+        def initialize(*)
+          @signal = Signal.new
+          super
+        end
+
+        def close(selector = Selector.new)
+          @signal.terminate
+          selector.deregister(@signal)
+          super(selector)
+        end
+
+        def select_connection(connection, selector)
+          super
+          selector.register(@signal)
+          connection.signal = @signal
+        end
+
+        def deselect_connection(connection, *)
+          super
+          connection.signal = nil
+        end
+      end
+
+      # Adds synchronization to request operations which may buffer payloads from different
+      # threads.
+      module RequestMethods
+        attr_accessor :headers_sent
+
+        def initialize(*)
+          super
+          @headers_sent = false
+          @closed = false
+          @mutex = Thread::Mutex.new
+        end
+
+        def closed?
+          @closed
+        end
+
+        def can_buffer?
+          super && @state != :waiting_for_chunk
+        end
+
+        # overrides state management transitions to introduce an intermediate
+        # +:waiting_for_chunk+ state, which the request transitions to once payload
+        # is buffered.
+        def transition(nextstate)
+          headers_sent = @headers_sent
+
+          case nextstate
+          when :waiting_for_chunk
+            return unless @state == :body
+          when :body
+            case @state
+            when :headers
+              headers_sent = true
+            when :waiting_for_chunk
+              # HACK: to allow super to pass through
+              @state = :headers
+            end
+          end
+
+          super.tap do
+            # delay setting this up until after the first transition to :body
+            @headers_sent = headers_sent
+          end
+        end
+
+        def <<(chunk)
+          @mutex.synchronize do
+            if @drainer
+              @body.clear if @body.respond_to?(:clear)
+              @drainer = nil
+            end
+            @body << chunk
+
+            transition(:body)
+          end
+        end
+
+        def close
+          @mutex.synchronize do
+            return if @closed
+
+            @closed = true
+          end
+
+          # last chunk to send which ends the stream
+          self << ""
+        end
+      end
+
+      module RequestBodyMethods
+        def initialize(*, **)
+          super
+          @headers.delete("content-length")
+        end
+
+        def empty?
+          false
+        end
+      end
+
+      # overrides the declaration of +@write_buffer+, which is now a thread-safe buffer
+      # responding to the same API.
+      module ConnectionMethods
+        attr_writer :signal
+
+        def initialize(*)
+          super
+          @write_buffer = BidiBuffer.new(@options.buffer_size)
+        end
+
+        # rebuffers the +@write_buffer+ before calculating interests.
+        def interests
+          @write_buffer.rebuffer
+
+          super
+        end
+
+        private
+
+        def parser_type(protocol)
+          return HTTP2Bidi if protocol == "h2"
+
+          super
+        end
+
+        def set_parser_callbacks(parser)
+          super
+          parser.on(:flush_buffer) do
+            @signal.wakeup if @signal
+          end
+        end
+      end
+    end
+    register_plugin :stream_bidi, StreamBidi
+  end
+end

data/lib/httpx/plugins/upgrade/h2.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for upgrading an HTTP/1.1 connection to HTTP/2
+    # via an Upgrade: h2 response declaration
+    #
+    # https://gitlab.com/os85/httpx/wikis/Connection-Upgrade#h2
+    #
+    module H2
+      class << self
+        def extra_options(options)
+          options.merge(upgrade_handlers: options.upgrade_handlers.merge("h2" => self))
+        end
+
+        def call(connection, _request, _response)
+          connection.upgrade_to_h2
+        end
+      end
+
+      module ConnectionMethods
+        using URIExtensions
+
+        def interests
+          return super unless connecting? && @parser
+
+          connect
+
+          return @io.interests if connecting?
+
+          super
+        end
+
+        def upgrade_to_h2
+          prev_parser = @parser
+
+          if prev_parser
+            prev_parser.reset
+            @inflight -= prev_parser.requests.size
+          end
+
+          @parser = @options.http2_class.new(@write_buffer, @options)
+          set_parser_callbacks(@parser)
+          @upgrade_protocol = "h2"
+
+          # what's happening here:
+          # a deviation from the state machine is done to perform the actions when a
+          # connection is closed, without transitioning, so the connection is kept in the pool.
+          # the state is reset to initial, so that the socket reconnect works out of the box,
+          # while the parser is already here.
+          purge_after_closed
+          transition(:idle)
+
+          prev_parser.requests.each do |req|
+            req.transition(:idle)
+            send(req)
+          end
+        end
+      end
+    end
+    register_plugin(:"upgrade/h2", H2)
+  end
+end

data/lib/httpx/plugins/upgrade.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin helps negotiating a new protocol from an HTTP/1.1 connection, via the
+    # Upgrade header.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Upgrade
+    #
+    module Upgrade
+      class << self
+        def configure(klass)
+          klass.plugin(:"upgrade/h2")
+        end
+
+        def extra_options(options)
+          options.merge(upgrade_handlers: {})
+        end
+      end
+
+      module OptionsMethods
+        private
+
+        def option_upgrade_handlers(value)
+          raise TypeError, ":upgrade_handlers must be a Hash" unless value.is_a?(Hash)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, selector, options)
+          response = super
+
+          if response
+            return response unless response.is_a?(Response)
+
+            return response unless response.headers.key?("upgrade")
+
+            upgrade_protocol = response.headers["upgrade"].split(/ *, */).first
+
+            return response unless upgrade_protocol && options.upgrade_handlers.key?(upgrade_protocol)
+
+            protocol_handler = options.upgrade_handlers[upgrade_protocol]
+
+            return response unless protocol_handler
+
+            log { "upgrading to #{upgrade_protocol}..." }
+            connection = find_connection(request.uri, selector, options)
+
+            # do not upgrade already upgraded connections
+            return if connection.upgrade_protocol == upgrade_protocol
+
+            protocol_handler.call(connection, request, response)
+
+            # keep in the loop if the server is switching, unless
+            # the connection has been hijacked, in which case you want
+            # to terminante immediately
+            return if response.status == 101 && !connection.hijacked
+          end
+
+          response
+        end
+      end
+
+      module ConnectionMethods
+        attr_reader :upgrade_protocol, :hijacked
+
+        def initialize(*)
+          super
+
+          @upgrade_protocol = nil
+        end
+
+        def hijack_io
+          @hijacked = true
+
+          # connection is taken away from selector and not given back to the pool.
+          @current_session.deselect_connection(self, @current_selector, true)
+        end
+      end
+    end
+    register_plugin(:upgrade, Upgrade)
+  end
+end

data/lib/httpx/plugins/webdav.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin implements convenience methods for performing WEBDAV requests.
+    #
+    # https://gitlab.com/os85/httpx/wikis/WebDav
+    #
+    module WebDav
+      def self.configure(klass)
+        klass.plugin(:xml)
+      end
+
+      module InstanceMethods
+        def copy(src, dest)
+          request("COPY", src, headers: { "destination" => @options.origin.merge(dest) })
+        end
+
+        def move(src, dest)
+          request("MOVE", src, headers: { "destination" => @options.origin.merge(dest) })
+        end
+
+        def lock(path, timeout: nil, &blk)
+          headers = {}
+          headers["timeout"] = if timeout && timeout.positive?
+            "Second-#{timeout}"
+          else
+            "Infinite, Second-4100000000"
+          end
+          xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" \
+                "<D:lockinfo xmlns:D=\"DAV:\">" \
+                "<D:lockscope><D:exclusive/></D:lockscope>" \
+                "<D:locktype><D:write/></D:locktype>" \
+                "<D:owner>null</D:owner>" \
+                "</D:lockinfo>"
+          response = request("LOCK", path, headers: headers, xml: xml)
+
+          return response unless response.is_a?(Response)
+
+          return response unless blk && response.status == 200
+
+          lock_token = response.headers["lock-token"]
+
+          begin
+            blk.call(response)
+          ensure
+            unlock(path, lock_token)
+          end
+
+          response
+        end
+
+        def unlock(path, lock_token)
+          request("UNLOCK", path, headers: { "lock-token" => lock_token })
+        end
+
+        def mkcol(dir)
+          request("MKCOL", dir)
+        end
+
+        def propfind(path, xml = nil)
+          body = case xml
+                 when :acl
+                   '<?xml version="1.0" encoding="utf-8" ?><D:propfind xmlns:D="DAV:"><D:prop><D:owner/>' \
+                   "<D:supported-privilege-set/><D:current-user-privilege-set/><D:acl/></D:prop></D:propfind>"
+                 when nil
+                   '<?xml version="1.0" encoding="utf-8"?><DAV:propfind xmlns:DAV="DAV:"><DAV:allprop/></DAV:propfind>'
+                 else
+                   xml
+          end
+
+          request("PROPFIND", path, headers: { "depth" => "1" }, xml: body)
+        end
+
+        def proppatch(path, xml)
+          body = "<?xml version=\"1.0\"?>" \
+                 "<D:propertyupdate xmlns:D=\"DAV:\" xmlns:Z=\"http://ns.example.com/standards/z39.50/\">#{xml}</D:propertyupdate>"
+          request("PROPPATCH", path, xml: body)
+        end
+        # %i[ orderpatch acl report search]
+      end
+    end
+    register_plugin(:webdav, WebDav)
+  end
+end

data/lib/httpx/plugins/xml.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin supports request XML encoding/response decoding using the nokogiri gem.
+    #
+    # https://gitlab.com/os85/httpx/wikis/XML
+    #
+    module XML
+      MIME_TYPES = %r{\b(application|text)/(.+\+)?xml\b}.freeze
+      module Transcoder
+        module_function
+
+        class Encoder
+          def initialize(xml)
+            @raw = xml
+          end
+
+          def content_type
+            charset = @raw.respond_to?(:encoding) && @raw.encoding ? @raw.encoding.to_s.downcase : "utf-8"
+            "application/xml; charset=#{charset}"
+          end
+
+          def bytesize
+            @raw.to_s.bytesize
+          end
+
+          def to_s
+            @raw.to_s
+          end
+        end
+
+        def encode(xml)
+          Encoder.new(xml)
+        end
+
+        def decode(response)
+          content_type = response.content_type.mime_type
+
+          raise HTTPX::Error, "invalid form mime type (#{content_type})" unless MIME_TYPES.match?(content_type)
+
+          Nokogiri::XML.method(:parse)
+        end
+      end
+
+      class << self
+        def load_dependencies(*)
+          require "nokogiri"
+        end
+      end
+
+      module ResponseMethods
+        # decodes the response payload into a Nokogiri::XML::Node object **if** the payload is valid
+        # "application/xml" (requires the "nokogiri" gem).
+        def xml
+          decode(Transcoder)
+        end
+      end
+
+      module RequestBodyClassMethods
+        #   ..., xml: Nokogiri::XML::Node #=> xml encoder
+        def initialize_body(params)
+          if (xml = params.delete(:xml))
+            # @type var xml: Nokogiri::XML::Node | String
+            return Transcoder.encode(xml)
+          end
+
+          super
+        end
+      end
+    end
+
+    register_plugin(:xml, XML)
+  end
+end

data/lib/httpx/pmatch_extensions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module ResponsePatternMatchExtensions
+    def deconstruct
+      [@status, @headers, @body]
+    end
+
+    def deconstruct_keys(_keys)
+      { status: @status, headers: @headers, body: @body }
+    end
+  end
+
+  module ErrorResponsePatternMatchExtensions
+    def deconstruct
+      [@error]
+    end
+
+    def deconstruct_keys(_keys)
+      { error: @error }
+    end
+  end
+
+  module HeadersPatternMatchExtensions
+    def deconstruct
+      to_a
+    end
+  end
+
+  Headers.include HeadersPatternMatchExtensions
+  Response.include ResponsePatternMatchExtensions
+  ErrorResponse.include ErrorResponsePatternMatchExtensions
+end